Esempio n. 1
0
        /// <summary>
        /// Performs projection for a single row. Evaluates each projection argument against the specified
        /// row, returning a result with the specified type.
        /// </summary>
        /// <param name="node">Projection expression.</param>
        /// <param name="row">Row to project.</param>
        /// <param name="resultType">Type of the projected row.</param>
        /// <returns>Projected row.</returns>
        private PropagatorResult Project(DbProjectExpression node, PropagatorResult row, TypeUsage resultType)
        {
            EntityUtil.CheckArgumentNull(node, "node");

            Debug.Assert(null != node.Projection, "CQT validates DbProjectExpression.Projection property");

            DbNewInstanceExpression projection = node.Projection as DbNewInstanceExpression;

            if (null == projection)
            {
                throw EntityUtil.NotSupported(System.Data.Entity.Strings.Update_UnsupportedProjection(node.Projection.ExpressionKind));
            }

            // Initialize empty structure containing space for every element of the projection.
            PropagatorResult[] projectedValues = new PropagatorResult[projection.Arguments.Count];

            // Extract value from the input row for every projection argument requested.
            for (int ordinal = 0; ordinal < projectedValues.Length; ordinal++)
            {
                projectedValues[ordinal] = Evaluator.Evaluate(projection.Arguments[ordinal], row, this);
            }

            // Return a new row containing projected values.
            PropagatorResult projectedRow = PropagatorResult.CreateStructuralValue(projectedValues, (StructuralType)resultType.EdmType, false);

            return(projectedRow);
        }
Esempio n. 2
0
 public override void Visit(DbProjectExpression e)
 {
     Begin(e);
     Dump(e.Input, "Input");
     Dump(e.Projection, "Projection");
     End(e);
 }
        private RowType GetRowTypeFromCommandTree(DbCommandTree tree)
        {
            DbQueryCommandTree commandTree = tree as DbQueryCommandTree;

            if (commandTree == null)
            {
                return(null);
            }

            DbProjectExpression projectExpression = commandTree.Query as DbProjectExpression;

            // Try filter then
            if (projectExpression == null)
            {
                DbFilterExpression filterExpression = commandTree.Query as DbFilterExpression;

                if (filterExpression != null && filterExpression.Input != null)
                {
                    projectExpression = filterExpression.Input.Expression as DbProjectExpression;
                }
            }

            if (projectExpression != null)
            {
                var newExpression = projectExpression.Projection;

                if (newExpression != null)
                {
                    return(newExpression.ResultType.EdmType as RowType);
                }
            }

            return(null);
        }
Esempio n. 4
0
        public override bool Visit(DbProjectExpression expression)
        {
            bool flag1 = VisitExpressionBinding(expression.Input);
            bool flag2 = VisitExpression(expression.Projection);

            return(flag1 || flag2);
        }
Esempio n. 5
0
 internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _skip    = skip;
     _source  = _skip.Input.Expression;
 }
Esempio n. 6
0
        /// <summary>
        /// Walks the structure
        /// </summary>
        /// <param name="expression">The DbProjectExpression that is being visited.</param>
        /// <returns></returns>
        public override bool Visit(DbProjectExpression expression)
        {
            bool inputNeedsRewrite      = VisitExpressionBinding(expression.Input);
            bool projectionNeedsRewrite = VisitExpression(expression.Projection);

            return(inputNeedsRewrite || projectionNeedsRewrite);
        }
Esempio n. 7
0
        // <summary>
        // Propagate projection.
        // Propagation rule (P = projection node, S = projection input, D(x) = deleted rows in x,
        // I(x) = inserted rows in x)
        // P = Proj_f S
        // D(P) = Proj_f D(S)
        // I(P) = Proj_f I(S)
        // </summary>
        // <param name="node"> Projection expression node. </param>
        // <returns> Result of propagating changes to the projection expression node. </returns>
        public override ChangeNode Visit(DbProjectExpression node)
        {
            Check.NotNull(node, "node");

            // Initialize an empty change node result for the projection node.
            var result = BuildChangeNode(node);

            // Retrieve result of propagating changes to the input of the projection.
            var input = Visit(node.Input.Expression);

            // Implement propagation rule for insert I(P) = Proj_f I(S)
            foreach (var row in input.Inserted)
            {
                result.Inserted.Add(Project(node, row, result.ElementType));
            }

            // Implement propagation rule for delete D(P) = Proj_f D(S)
            foreach (var row in input.Deleted)
            {
                result.Deleted.Add(Project(node, row, result.ElementType));
            }

            // Generate a placeholder for the projection node by projecting values in the
            // placeholder for the input node.
            result.Placeholder = Project(node, input.Placeholder, result.ElementType);

            return(result);
        }
Esempio n. 8
0
 internal ProjectSortLifter(DbProjectExpression project, DbSortExpression sort, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _sort    = sort;
     _source  = sort.Input.Expression;
 }
Esempio n. 9
0
        // <summary>
        // Performs projection for a single row. Evaluates each projection argument against the specified
        // row, returning a result with the specified type.
        // </summary>
        // <param name="node"> Projection expression. </param>
        // <param name="row"> Row to project. </param>
        // <param name="resultType"> Type of the projected row. </param>
        // <returns> Projected row. </returns>
        private static PropagatorResult Project(DbProjectExpression node, PropagatorResult row, TypeUsage resultType)
        {
            DebugCheck.NotNull(node);

            DebugCheck.NotNull(node.Projection);

            var projection = node.Projection as DbNewInstanceExpression;

            if (null == projection)
            {
                throw new NotSupportedException(Strings.Update_UnsupportedProjection(node.Projection.ExpressionKind));
            }

            // Initialize empty structure containing space for every element of the projection.
            var projectedValues = new PropagatorResult[projection.Arguments.Count];

            // Extract value from the input row for every projection argument requested.
            for (var ordinal = 0; ordinal < projectedValues.Length; ordinal++)
            {
                projectedValues[ordinal] = Evaluator.Evaluate(projection.Arguments[ordinal], row);
            }

            // Return a new row containing projected values.
            var projectedRow = PropagatorResult.CreateStructuralValue(projectedValues, (StructuralType)resultType.EdmType, false);

            return(projectedRow);
        }
Esempio n. 10
0
 public override void Visit(DbProjectExpression expression)
 {
     EntityUtils.CheckArgumentNull <DbProjectExpression>(expression, nameof(expression));
     this.VisitExpressionBindingPre(expression.Input);
     this.VisitExpression(expression.Projection);
     this.VisitExpressionBindingPost(expression.Input);
 }
Esempio n. 11
0
            public override DbExpression Visit(DbProjectExpression expression)
            {
                // Only allowed cases:
                // SELECT Deref(x) FROM <expression> AS x
                // SELECT x FROM <expression> as x
                DbExpression testExpr = expression.Projection;

                if (DbExpressionKind.Deref == testExpr.ExpressionKind)
                {
                    testExpr = ((DbDerefExpression)testExpr).Argument;
                }

                if (DbExpressionKind.VariableReference == testExpr.ExpressionKind)
                {
                    DbVariableReferenceExpression varRef = (DbVariableReferenceExpression)testExpr;
                    if (varRef.VariableName.Equals(expression.Input.VariableName, StringComparison.Ordinal))
                    {
                        DbExpression found = Find(expression.Input.Expression);
                        if (!object.ReferenceEquals(found, expression.Input.Expression))
                        {
                            return(found.BindAs(expression.Input.VariableName).Project(expression.Projection));
                        }
                    }
                }

                return(expression);
            }
Esempio n. 12
0
 internal ProjectLimitSortLifter(
     DbProjectExpression project, DbLimitExpression limit, DbSortExpression sort, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _limit   = limit;
     _sort    = sort;
 }
Esempio n. 13
0
        public override DbExpression Translate(ExpressionParser parser, MethodCallExpression callExpression)
        {
            DbProjectExpression input  = parser.Parse(callExpression.Arguments[0]) as DbProjectExpression;
            LambdaExpression    lambda = parser.GetLambdaExpression(callExpression.Arguments[1]);
            DbExpression        body   = parser.ParseLambda(input.Input, lambda);

            return(new DbWhereExpression(input.Input, body, input.ResultType));
        }
Esempio n. 14
0
 public override void Visit(DbProjectExpression e)
 {
     Check.NotNull <DbProjectExpression>(e, nameof(e));
     this.Begin((DbExpression)e);
     this.Dump(e.Input, "Input");
     this.Dump(e.Projection, "Projection");
     this.End((DbExpression)e);
 }
Esempio n. 15
0
            public override DbExpressionEntitySetInfo Visit(DbProjectExpression expression)
            {
                this.VisitExpressionBindingEnterScope(expression.Input);
                DbExpressionEntitySetInfo setInfo = VisitExpression(expression.Projection);

                this.VisitExpressionBindingExitScope();
                return(setInfo);
            }
Esempio n. 16
0
 public override void Visit(DbProjectExpression expression)
 {
     Write(expression);
     _depth++;
     Write("Input", expression.Input);
     Write("Projection", expression.Projection);
     _depth--;
 }
Esempio n. 17
0
        public override LegacyCommandTrees.DbExpression Visit(DbProjectExpression expression)
        {
            Debug.Assert(expression != null, "expression != null");

            return(expression.Input.Expression.Accept(this)
                   .BindAs(expression.Input.VariableName)
                   .Project(expression.Projection.Accept(this)));
        }
Esempio n. 18
0
            public override TreeNode Visit(DbProjectExpression e)
            {
                TreeNode retInfo = NodeFromExpression(e);

                retInfo.Children.Add(this.VisitBinding("Input", e.Input));
                retInfo.Children.Add(this.Visit("Projection", e.Projection));
                return(retInfo);
            }
Esempio n. 19
0
 internal override DbExpression Project(DbProjectExpression project)
 {
     // source.Sort(o).Limit(k).Project(p).Project(p2) -> source.Sort(o).Limit(k).Project(e => p2(p(e)))
     return(ComposeProject(
                DbExpressionBuilder.Limit(_sort, _limit.Limit),
                _project,
                project));
 }
Esempio n. 20
0
 public override void Visit(DbProjectExpression e)
 {
     VisitExprKind(e.ExpressionKind);
     _key.Append('(');
     VisitBinding(e.Input);
     _key.Append('(');
     e.Projection.Accept(this);
     _key.Append("))");
 }
Esempio n. 21
0
        /// <summary>
        ///     Walks the structure
        /// </summary>
        /// <param name="expression"> The DbProjectExpression that is being visited. </param>
        /// <returns> </returns>
        public override bool Visit(DbProjectExpression expression)
        {
            Check.NotNull(expression, "expression");

            var inputNeedsRewrite      = VisitExpressionBinding(expression.Input);
            var projectionNeedsRewrite = VisitExpression(expression.Projection);

            return(inputNeedsRewrite || projectionNeedsRewrite);
        }
Esempio n. 22
0
 internal override DbExpression Project(DbProjectExpression project)
 {
     // source.Skip(k, o).Limit(k2).Project(p).Project(p2) ->
     // source.Skip(k, o).Limit(k2).Project(e => p2(p(e)))
     return(ComposeProject(
                _skip.Limit(_limit.Limit),
                _project,
                project));
 }
Esempio n. 23
0
        /// <summary>
        ///     Visitor pattern method for <see cref="DbProjectExpression" />.
        /// </summary>
        /// <param name="expression"> The DbProjectExpression that is being visited. </param>
        /// <exception cref="ArgumentNullException">
        ///     <paramref name="expression" />
        ///     is null
        /// </exception>
        public override void Visit(DbProjectExpression expression)
        {
            // #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
            Check.NotNull(expression, "expression");

            VisitExpressionBindingPre(expression.Input);
            VisitExpression(expression.Projection);
            VisitExpressionBindingPost(expression.Input);
        }
Esempio n. 24
0
            public override TreeNode Visit(DbProjectExpression e)
            {
                Check.NotNull <DbProjectExpression>(e, nameof(e));
                TreeNode treeNode = ExpressionPrinter.PrinterVisitor.NodeFromExpression((DbExpression)e);

                treeNode.Children.Add(this.VisitBinding("Input", e.Input));
                treeNode.Children.Add(this.Visit("Projection", e.Projection));
                return(treeNode);
            }
 public override ViewValidator.DbExpressionEntitySetInfo Visit(
     DbProjectExpression expression)
 {
     Check.NotNull <DbProjectExpression>(expression, nameof(expression));
     this.VisitExpressionBindingEnterScope(expression.Input);
     ViewValidator.DbExpressionEntitySetInfo expressionEntitySetInfo = this.VisitExpression(expression.Projection);
     this.VisitExpressionBindingExitScope();
     return(expressionEntitySetInfo);
 }
Esempio n. 26
0
        public override void Visit(DbProjectExpression e)
        {
            Check.NotNull(e, "e");

            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Projection, "Projection");
            End(e);
        }
        private DbExpression RewriteCollection(DbExpression expression)
        {
            DbExpression        dbExpression      = expression;
            DbProjectExpression projectExpression = (DbProjectExpression)null;

            if (DbExpressionKind.Project == expression.ExpressionKind)
            {
                projectExpression = (DbProjectExpression)expression;
                dbExpression      = projectExpression.Input.Expression;
            }
            ObjectSpanRewriter.NavigationInfo navInfo = (ObjectSpanRewriter.NavigationInfo)null;
            if (this.RelationshipSpan)
            {
                dbExpression = ObjectSpanRewriter.RelationshipNavigationVisitor.FindNavigationExpression(dbExpression, this._aliasGenerator, out navInfo);
            }
            if (navInfo != null)
            {
                this.EnterNavigationCollection(navInfo);
            }
            else
            {
                this.EnterCollection();
            }
            DbExpression body = expression;

            if (projectExpression != null)
            {
                DbExpression projection = this.Rewrite(projectExpression.Projection);
                if (!object.ReferenceEquals((object)projectExpression.Projection, (object)projection))
                {
                    body = (DbExpression)dbExpression.BindAs(projectExpression.Input.VariableName).Project(projection);
                }
            }
            else
            {
                DbExpressionBinding input      = dbExpression.BindAs(this._aliasGenerator.Next());
                DbExpression        variable   = (DbExpression)input.Variable;
                DbExpression        projection = this.Rewrite(variable);
                if (!object.ReferenceEquals((object)variable, (object)projection))
                {
                    body = (DbExpression)input.Project(projection);
                }
            }
            this.ExitCollection();
            if (navInfo != null && navInfo.InUse)
            {
                body = (DbExpression)DbExpressionBuilder.Lambda(body, (IEnumerable <DbVariableReferenceExpression>) new List <DbVariableReferenceExpression>(1)
                {
                    navInfo.SourceVariable
                }).Invoke((IEnumerable <DbExpression>) new List <DbExpression>(1)
                {
                    navInfo.Source
                });
            }
            return(body);
        }
Esempio n. 28
0
            public override TreeNode Visit(DbProjectExpression e)
            {
                Check.NotNull(e, "e");

                var retInfo = NodeFromExpression(e);

                retInfo.Children.Add(VisitBinding("Input", e.Input));
                retInfo.Children.Add(Visit("Projection", e.Projection));
                return(retInfo);
            }
Esempio n. 29
0
 public override void Visit(DbProjectExpression expression)
 {
     if (expression == null)
     {
         throw new ArgumentException("expression");
     }
     VisitExpressionBindingPre(expression.Input);
     VisitExpression(expression.Projection);
     VisitExpressionBindingPost(expression.Input);
 }
Esempio n. 30
0
            public override DbExpressionEntitySetInfo Visit(DbProjectExpression expression)
            {
                Check.NotNull(expression, "expression");

                VisitExpressionBindingEnterScope(expression.Input);
                var setInfo = VisitExpression(expression.Projection);

                VisitExpressionBindingExitScope();
                return(setInfo);
            }
        public override Expression Visit(DbProjectExpression expression)
        {
            Expression source = this.Visit(expression.Input.Expression);

            Type elementType = TypeHelper.GetElementType(source.Type);

            ParameterExpression param = Expression.Parameter(elementType, expression.Input.VariableName);
            using (this.CreateVariable(param, expression.Input.VariableName))
            {
                Expression projection = this.Visit(expression.Projection);
                LambdaExpression projectionLambda = Expression.Lambda(projection, param);

                return queryMethodExpressionBuilder.Select(source, projectionLambda);
            }
        }
 public override DbExpression Visit(DbProjectExpression expression)
 {
     System.Diagnostics.Debug.Print("Visit(DbProjectExpression): {0}", expression);
     return base.Visit(expression);
 }
 public override void Visit(DbProjectExpression e)
 {
     VisitExprKind(e.ExpressionKind);
     _key.Append('(');
     VisitBinding(e.Input);
     _key.Append('(');
     e.Projection.Accept(this);
     _key.Append("))");
 }
		public override void Visit(DbProjectExpression expression)
		{
			throw new NotSupportedException("Visit(\"ProjectExpression\") is not supported.");
		}
Esempio n. 35
0
 /// <summary>
 ///     Visitor pattern method for DbProjectExpression.
 /// </summary>
 /// <param name="expression"> The DbProjectExpression that is being visited. </param>
 public abstract void Visit(DbProjectExpression expression);
 protected DbProjectExpression RebindProject(DbExpression input, DbProjectExpression project)
 {
     DbExpressionBinding inputBinding = input.BindAs(project.Input.VariableName);
     return inputBinding.Project(project.Projection);
 }
Esempio n. 37
0
                protected static DbProjectExpression ComposeProject(
                    DbExpression input, DbProjectExpression first, DbProjectExpression second)
                {
                    // source.Project(first).Project(second) -> source.Project(e => second(first(e)))

                    // create lambda expression representing the second projection (e => second(e))
                    var secondLambda = DbExpressionBuilder.Lambda(second.Projection, second.Input.Variable);

                    // invoke lambda with variable from the first projection
                    var composed = first.Input.Project(secondLambda.Invoke(first.Projection));

                    return RebindProject(input, composed);
                }
Esempio n. 38
0
 public override void Visit(DbProjectExpression expression)
 {
     Contract.Requires(expression != null);
 }
        public override void Visit(DbProjectExpression e)
        {
            Check.NotNull(e, "e");

            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Projection, "Projection");
            End(e);
        }
 internal override DbExpression Project(DbProjectExpression project)
 {
     // the result is already ordered (no compensation is required)
     return project;
 }
 internal override DbExpression Project(DbProjectExpression project)
 {
     return project;
 }
 public override void Visit(DbProjectExpression e)
 {
     Begin(e);
     Dump(e.Input, "Input");
     Dump(e.Projection, "Projection");
     End(e);
 }
Esempio n. 43
0
 public override void Visit(DbProjectExpression expression)
 {
   if (expression == null) throw new ArgumentException("expression");
   VisitExpressionBindingPre(expression.Input);
   VisitExpression(expression.Projection);
   VisitExpressionBindingPost(expression.Input);
 }
Esempio n. 44
0
 internal ProjectLimitSortLifter(
     DbProjectExpression project, DbLimitExpression limit, DbSortExpression sort, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _limit = limit;
     _sort = sort;
 }
 public override void Visit(DbProjectExpression expression) { }
Esempio n. 46
0
            public override DbExpression Visit(DbProjectExpression expression)
            {
                // Only allowed cases:
                // SELECT Deref(x) FROM <expression> AS x
                // SELECT x FROM <expression> as x
                DbExpression testExpr = expression.Projection;
                if (DbExpressionKind.Deref == testExpr.ExpressionKind)
                {
                    testExpr = ((DbDerefExpression)testExpr).Argument;
                }

                if (DbExpressionKind.VariableReference == testExpr.ExpressionKind)
                {
                    DbVariableReferenceExpression varRef = (DbVariableReferenceExpression)testExpr;
                    if (varRef.VariableName.Equals(expression.Input.VariableName, StringComparison.Ordinal))
                    {
                        DbExpression found = Find(expression.Input.Expression);
                        if (!object.ReferenceEquals(found, expression.Input.Expression))
                        {
                            return found.BindAs(expression.Input.VariableName).Project(expression.Projection);
                        }
                    }
                }

                return expression;
            }
        /// <summary>
        ///     Visitor pattern method for <see cref="DbProjectExpression" />.
        /// </summary>
        /// <param name="expression"> The DbProjectExpression that is being visited. </param>
        /// <exception cref="ArgumentNullException">
        ///     <paramref name="expression" />
        ///     is null
        /// </exception>
        public override void Visit(DbProjectExpression expression)
        {
            Check.NotNull(expression, "expression");

            VisitExpressionBindingPre(expression.Input);
            VisitExpression(expression.Projection);
            VisitExpressionBindingPost(expression.Input);
        }
Esempio n. 48
0
        /// <summary>
        ///     Visitor pattern method for <see cref="DbProjectExpression" />.
        /// </summary>
        /// <param name="expression"> The DbProjectExpression that is being visited. </param>
        /// <exception cref="ArgumentNullException">
        ///     <paramref name="expression" />
        ///     is null
        /// </exception>
        public override void Visit(DbProjectExpression expression)
        {
            // #433613: PreSharp warning 56506: Parameter 'expression' to this public method must be validated: A null-dereference can occur here.
            Check.NotNull(expression, "expression");

            VisitExpressionBindingPre(expression.Input);
            VisitExpression(expression.Projection);
            VisitExpressionBindingPost(expression.Input);
        }
 internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _skip = skip;
     _source = _skip.Input.Expression;
 }
 internal override DbExpression Project(DbProjectExpression project)
 {
     // source.Sort(o).Limit(k).Project(p).Project(p2) -> source.Sort(o).Limit(k).Project(e => p2(p(e)))
     return ComposeProject(
         DbExpressionBuilder.Limit(_sort, _limit.Limit),
         _project,
         project);
 }
        public override SqlFragment Visit(DbProjectExpression expression)
        {
            SelectStatement select = VisitInputExpressionEnsureSelect(expression.Input.Expression, 
                expression.Input.VariableName, expression.Input.VariableType);

            // see if we need to wrap this select inside a new select
            select = WrapIfNotCompatible(select, expression.ExpressionKind);

            Debug.Assert(expression.Projection is DbNewInstanceExpression);
            VisitNewInstanceExpression(select, expression.Projection as DbNewInstanceExpression);

            return select;
        }
 internal override DbExpression Project(DbProjectExpression project)
 {
     // source.Skip(k, o).Project(p).Project(p2) -> source.Skip(k, o).Project(e => p2(p(e)))
     return ComposeProject(_skip, _project, project);
 }
Esempio n. 53
0
        /// <summary>
        /// Implements the visitor pattern for <see cref="T:System.Data.Common.CommandTrees.DbProjectExpression"/>.
        /// </summary>
        /// <param name="expression">The <see cref="T:System.Data.Common.CommandTrees.DbProjectExpression"/> that is visited.</param>
        public override void Visit(DbProjectExpression expression)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            expression.Projection.Accept(this);
            expression.Input.Expression.Accept(this);
        }
 internal ProjectSortLifter(DbProjectExpression project, DbSortExpression sort, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _sort = sort;
     _source = sort.Input.Expression;
 }
 internal abstract DbExpression Project(DbProjectExpression project);
 internal override DbExpression Project(DbProjectExpression project)
 {
     // source.Sort(o).Project(p).Project(p2) -> source.Sort(o).Project(e => p2(p(2)))
     return ComposeProject(_sort, _project, project);
 }
                protected DbFilterExpression ComposeFilter(DbExpression input, DbProjectExpression first, DbFilterExpression second)
                {
                    // source.Project(first).Filter(second) -> source.Filter(e => second(first(e)))

                    // create lambda expression representing the filter (e => second(e))
                    DbLambda secondLambda = DbExpressionBuilder.Lambda(second.Predicate, second.Input.Variable);

                    // invoke lambda with variable from the project
                    DbFilterExpression composed = first.Input.Filter(secondLambda.Invoke(first.Projection));

                    return RebindFilter(input, composed);
                }
 /// <summary>
 /// Visitor pattern method for <see cref="DbProjectExpression"/>.
 /// </summary>
 /// <param name="expression">The DbProjectExpression that is being visited.</param>
 /// <exception cref="ArgumentNullException"><paramref name="expression"/> is null</exception>
 public override void Visit(DbProjectExpression expression)
 {
     VisitExpressionBindingPre(expression.Input);
     VisitExpression(expression.Projection);
     VisitExpressionBindingPost(expression.Input);
 }