Beispiel #1
0
        protected virtual Expression VisitClientJoin(DbClientJoinExpression join)
        {
            DbProjectionExpression          projection = (DbProjectionExpression)Visit(join.Projection);
            ReadOnlyCollection <Expression> outerKey   = VisitExpressionList(join.OuterKey);
            ReadOnlyCollection <Expression> innerKey   = VisitExpressionList(join.InnerKey);

            return(UpdateClientJoin(join, projection, outerKey, innerKey));
        }
Beispiel #2
0
        protected DbClientJoinExpression UpdateClientJoin(DbClientJoinExpression join,
                                                          DbProjectionExpression projection, IEnumerable <Expression> outerKey,
                                                          IEnumerable <Expression> innerKey)
        {
            if (projection != join.Projection || outerKey != join.OuterKey || innerKey != join.InnerKey)
            {
                return(new DbClientJoinExpression(projection, outerKey, innerKey));
            }

            return(join);
        }
Beispiel #3
0
        protected override Expression VisitClientJoin(DbClientJoinExpression join)
        {
            var innerKey = this.VisitExpressionList(join.InnerKey);
            var outerKey = this.VisitExpressionList(join.OuterKey);
            DbProjectionExpression projection = (DbProjectionExpression)this.Visit(join.Projection);

            if (projection != join.Projection || innerKey != join.InnerKey || outerKey != join.OuterKey)
            {
                return(new DbClientJoinExpression(projection, outerKey, innerKey));
            }
            return(join);
        }
 protected override Expression VisitClientJoin(DbClientJoinExpression join)
 {
     // treat client joins as new top level
     var saveTop = this.isTopLevel;
     var saveSelect = this.currentSelect;
     this.isTopLevel = true;
     this.currentSelect = null;
     Expression result = base.VisitClientJoin(join);
     this.isTopLevel = saveTop;
     this.currentSelect = saveSelect;
     return result;
 }
Beispiel #5
0
        protected override Expression VisitClientJoin(DbClientJoinExpression join)
        {
            // treat client joins as new top level
            var saveTop    = this.isTopLevel;
            var saveSelect = this.currentSelect;

            this.isTopLevel    = true;
            this.currentSelect = null;
            Expression result = base.VisitClientJoin(join);

            this.isTopLevel    = saveTop;
            this.currentSelect = saveSelect;
            return(result);
        }
Beispiel #6
0
        protected override Expression VisitClientJoin(DbClientJoinExpression join)
        {
            // convert client join into a up-front lookup table builder & replace client-join in tree with lookup accessor

            // 1) lookup = query.Select(e => new KVP(key: inner, value: e)).ToLookup(kvp => kvp.Key, kvp => kvp.Value)
            Expression innerKey = MakeJoinKey(join.InnerKey);
            Expression outerKey = MakeJoinKey(join.OuterKey);

            ConstructorInfo        kvpConstructor  = typeof(KeyValuePair <,>).MakeGenericType(innerKey.Type, join.Projection.Projector.Type).GetConstructor(new Type[] { innerKey.Type, join.Projection.Projector.Type });
            Expression             constructKVPair = Expression.New(kvpConstructor, innerKey, join.Projection.Projector);
            DbProjectionExpression newProjection   = new DbProjectionExpression(join.Projection.Select, constructKVPair);

            int        iLookup   = ++nLookup;
            Expression execution = this.ExecuteProjection(newProjection, false);

            ParameterExpression kvp = Expression.Parameter(constructKVPair.Type, "kvp");

            // filter out nulls
            if (join.Projection.Projector.NodeType == (ExpressionType)DbExpressionType.OuterJoined)
            {
                LambdaExpression pred = Expression.Lambda(
                    Expression.PropertyOrField(kvp, "Value").NotEqual(TypeHelper.GetNullConstant(join.Projection.Projector.Type)),
                    kvp
                    );
                execution = Expression.Call(typeof(Enumerable), "Where", new Type[] { kvp.Type }, execution, pred);
            }

            // make lookup
            LambdaExpression keySelector     = Expression.Lambda(Expression.PropertyOrField(kvp, "Key"), kvp);
            LambdaExpression elementSelector = Expression.Lambda(Expression.PropertyOrField(kvp, "Value"), kvp);
            Expression       toLookup        = Expression.Call(typeof(Enumerable), "ToLookup", new Type[] { kvp.Type, outerKey.Type, join.Projection.Projector.Type }, execution, keySelector, elementSelector);

            // 2) agg(lookup[outer])
            ParameterExpression lookup   = Expression.Parameter(toLookup.Type, "lookup" + iLookup);
            PropertyInfo        property = lookup.Type.GetProperty("Item");
            Expression          access   = Expression.Call(lookup, property.GetGetMethod(), this.Visit(outerKey));

            if (join.Projection.Aggregator != null)
            {
                // apply aggregator
                access = DbExpressionReplacer.Replace(join.Projection.Aggregator.Body, join.Projection.Aggregator.Parameters[0], access);
            }

            this.variables.Add(lookup);
            this.initializers.Add(toLookup);

            return(access);
        }
 protected DbClientJoinExpression UpdateClientJoin(DbClientJoinExpression join, 
     DbProjectionExpression projection, IEnumerable<Expression> outerKey, 
     IEnumerable<Expression> innerKey)
 {
     if (projection != join.Projection || outerKey != join.OuterKey || innerKey != join.InnerKey)
         return new DbClientJoinExpression(projection, outerKey, innerKey);
     
     return join;
 }
        protected virtual Expression VisitClientJoin(DbClientJoinExpression join)
        {
            DbProjectionExpression projection = (DbProjectionExpression)Visit(join.Projection);
            ReadOnlyCollection<Expression> outerKey = VisitExpressionList(join.OuterKey);
            ReadOnlyCollection<Expression> innerKey = VisitExpressionList(join.InnerKey);

            return UpdateClientJoin(join, projection, outerKey, innerKey);
        }
 protected override Expression VisitClientJoin(DbClientJoinExpression join)
 {
     var innerKey = this.VisitExpressionList(join.InnerKey);
     var outerKey = this.VisitExpressionList(join.OuterKey);
     DbProjectionExpression projection = (DbProjectionExpression)this.Visit(join.Projection);
     if (projection != join.Projection || innerKey != join.InnerKey || outerKey != join.OuterKey)
     {
         return new DbClientJoinExpression(projection, outerKey, innerKey);
     }
     return join;
 }