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);
            }
        }

 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);
 }

        /// <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);
        }

        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;
        }

		public override void Visit(DbProjectExpression expression)
		{
			throw new NotSupportedException("Visit(\"ProjectExpression\") is not supported.");
		}

            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;
            }

 internal ProjectSortLifter(DbProjectExpression project, DbSortExpression sort, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _sort = sort;
     _source = sort.Input.Expression;
 }

 public override void Visit(DbProjectExpression expression) { }

 internal ProjectLimitSortLifter(
     DbProjectExpression project, DbLimitExpression limit, DbSortExpression sort, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _limit = limit;
     _sort = sort;
 }

 public override DbExpression Visit(DbProjectExpression expression)
 {
     System.Diagnostics.Debug.Print("Visit(DbProjectExpression): {0}", expression);
     return base.Visit(expression);
 }

                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);
                }

        /// <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);
        }

        public override void Visit(DbProjectExpression e)
        {
            Check.NotNull(e, "e");

            Begin(e);
            Dump(e.Input, "Input");
            Dump(e.Projection, "Projection");
            End(e);
        }

 internal ProjectSkipLifter(DbProjectExpression project, DbSkipExpression skip, AliasGenerator aliasGenerator)
     : base(project, aliasGenerator)
 {
     _project = project;
     _skip = skip;
     _source = _skip.Input.Expression;
 }

 public override void Visit(DbProjectExpression e)
 {
     Begin(e);
     Dump(e.Input, "Input");
     Dump(e.Projection, "Projection");
     End(e);
 }

 /// <summary>
 ///     Visitor pattern method for DbProjectExpression.
 /// </summary>
 /// <param name="expression"> The DbProjectExpression that is being visited. </param>
 public abstract void Visit(DbProjectExpression expression);

                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);
                }

 public override void Visit(DbProjectExpression e)
 {
     VisitExprKind(e.ExpressionKind);
     _key.Append('(');
     VisitBinding(e.Input);
     _key.Append('(');
     e.Projection.Accept(this);
     _key.Append("))");
 }

 protected DbProjectExpression RebindProject(DbExpression input, DbProjectExpression project)
 {
     DbExpressionBinding inputBinding = input.BindAs(project.Input.VariableName);
     return inputBinding.Project(project.Projection);
 }

 public override void Visit(DbProjectExpression expression)
 {
   if (expression == null) throw new ArgumentException("expression");
   VisitExpressionBindingPre(expression.Input);
   VisitExpression(expression.Projection);
   VisitExpressionBindingPost(expression.Input);
 }