Example #1
0
        public void InnerJoinLogicalRewriter_MultiFieldKey()
        {
            // NOTE: some parameter names are hard coded into the optimizer

            TestDatabase db = new TestDatabase();

            Expression expression = CreateExpression(() =>
                                                     db.Members.SelectMany(m =>
                                                                           db.Groups.Where(g => g.Id == m.GroupId && m.GroupId2 == g.Id2),
                                                                           (outer, inner) => new { Member = outer, Group = inner }));

            Expression expectedExpression = CreateExpression(() =>
                                                             db.Members.Join(
                                                                 db.Groups,
                                                                 outer => new Tuple <int?, int>(outer.GroupId, outer.GroupId2),
                                                                 inner => new Tuple <int?, int>(inner.Id, inner.Id2),
                                                                 (outer, inner) => new { Member = outer, Group = inner }));

            IExpressionRewriter rewriter = new InnerJoinLogicalRewriter();

            expression = rewriter.Rewrite(expression);

            Assert.AreEqual(expectedExpression.Type, expression.Type);
            Assert.AreEqual(expectedExpression.ToString(), expression.ToString());
        }
Example #2
0
        public void InnerJoinLogicalRewriter_OmitRewrite()
        {
            TestDatabase db         = new TestDatabase();
            Expression   expression = CreateExpression(() =>
                                                       db.Members.SelectMany(
                                                           m => db.Groups
                                                           .Where(g => g.Name.Length > m.GroupId)
                                                           .Where(g => g.Id == m.GroupId),
                                                           (m, g) => new { m, g }));

            string expected = expression.ToString();

            IExpressionRewriter rewriter = new InnerJoinLogicalRewriter();

            expression = rewriter.Rewrite(expression);

            Assert.AreEqual(
                expected,
                expression.ToString());
        }
Example #3
0
        public void InnerJoinLogicalRewriter_TripleJoin()
        {
            // NOTE: some parameter names are hard coded into the optimizer

            TestDatabase db = new TestDatabase();

            Expression expression = CreateExpression(() =>
                                                     db.Members.SelectMany(m =>
                                                                           db.Groups.Where(g =>
                                                                                           g.Id == m.GroupId),
                                                                           (outer, inner) =>
                                                                           new
            {
                Member = outer,
                Group  = inner
            })
                                                     .SelectMany(m =>
                                                                 db.Groups.Where(g =>
                                                                                 g.Id == m.Member.GroupId),
                                                                 (outer, inner) =>
                                                                 new
            {
                Member = outer.Member,
                Group1 = outer.Group,
                Group2 = inner
            })
                                                     .SelectMany(m =>
                                                                 db.Groups.Where(g =>
                                                                                 g.Id == m.Member.GroupId),
                                                                 (outer, inner) =>
                                                                 new
            {
                Member = outer.Member,
                Group1 = outer.Group1,
                Group2 = outer.Group2,
                Group3 = inner
            }));

            Expression expectedExpression = CreateExpression(() =>
                                                             db.Members.Join(
                                                                 db.Groups,
                                                                 outer =>
                                                                 outer.GroupId,
                                                                 inner =>
                                                                 inner.Id,
                                                                 (outer, inner) =>
                                                                 new
            {
                Member = outer,
                Group  = inner
            })
                                                             .Join(
                                                                 db.Groups,
                                                                 outer => outer.Member.GroupId,
                                                                 inner => inner.Id,
                                                                 (outer, inner) =>
                                                                 new
            {
                Member = outer.Member,
                Group1 = outer.Group,
                Group2 = inner
            })
                                                             .Join(
                                                                 db.Groups,
                                                                 outer => outer.Member.GroupId,
                                                                 inner => inner.Id,
                                                                 (outer, inner) =>
                                                                 new
            {
                Member = outer.Member,
                Group1 = outer.Group1,
                Group2 = outer.Group2,
                Group3 = inner
            }));

            IExpressionRewriter rewriter = new InnerJoinLogicalRewriter();

            expression = rewriter.Rewrite(expression);

            Assert.AreEqual(expectedExpression.Type, expression.Type);
            Assert.AreEqual(expectedExpression.ToString(), expression.ToString());
        }