CodePlex#2296 and CodePlex#2256 - Joins not being eliminated

 JoinElimination and PostJoinElimination transformations were run only twice. In addition the Deffered transformations were run after JoinElimination. The IQT can be simplified further in some cases by repeatedly running JoinElimination and PostJoinElimination transformations until the tree remains un-modified.

The change removes the Deferred transformation rule group and updates the PostJoinElimination rule group to include ApplyOpRules. Then it runs JoinElimination and PostJoinElimination transformations until the IQT does not change anymore, for a maximum of 10 iterations. Included two unit tests for two scenarios described in the bugs.

Author: Emil Cicos

src/EntityFramework/Core/Query/PlanCompiler/PlanCompiler.cs

@@ -267,13 +267,10 @@ private void Compile(
             var beforeTransformationRules1 = String.Empty;
             var beforeProjectionPruning3 = String.Empty;
             var beforeTransformationRules2 = String.Empty;
-            var beforeJoinElimination1 = String.Empty;
+            var beforeNullSemantics = String.Empty;
             var beforeTransformationRules3 = String.Empty;
-            var beforeJoinElimination2 = String.Empty;
+            var beforeJoinElimination = String.Empty;
             var beforeTransformationRules4 = String.Empty;
-            var beforeNullSemantics = String.Empty;
-            var beforeTransformationRules5 = String.Empty;
-            var beforeTransformationRules6 = String.Empty;
             var beforeCodeGen = String.Empty;
 
             //
@@ -364,25 +361,27 @@ private void Compile(
             // Join elimination
             if (IsPhaseNeeded(PlanCompilerPhase.JoinElimination))
             {
-                beforeJoinElimination1 = SwitchToPhase(PlanCompilerPhase.JoinElimination);
-                var modified = JoinElimination.Process(this);
-                if (modified)
+                const int maxIterations = 10;
+
+                for (var i = 0; i < maxIterations; i++)
                 {
-                    ApplyTransformations(ref beforeTransformationRules4, TransformationRulesGroup.PostJoinElimination);
-                    beforeJoinElimination2 = SwitchToPhase(PlanCompilerPhase.JoinElimination);
-                    modified = JoinElimination.Process(this);
-                    if (modified)
+                    beforeJoinElimination = SwitchToPhase(PlanCompilerPhase.JoinElimination);
+
+                    var modified = JoinElimination.Process(this);
+
+                    if (modified || TransformationsDeferred)
                     {
-                        ApplyTransformations(ref beforeTransformationRules5, TransformationRulesGroup.PostJoinElimination);
+                        TransformationsDeferred = false;
+
+                        ApplyTransformations(ref beforeTransformationRules4, TransformationRulesGroup.PostJoinElimination);
+                    }
+                    else
+                    {
+                        break;
                     }
                 }
             }
 
-            if (TransformationsDeferred)
-            {
-                ApplyTransformations(ref beforeTransformationRules6, TransformationRulesGroup.Deferred);
-            }
-
             // Code generation
             beforeCodeGen = SwitchToPhase(PlanCompilerPhase.CodeGen);
             CodeGen.Process(this, out providerCommands, out resultColumnMap, out columnCount);
@@ -399,13 +398,10 @@ private void Compile(
             size = beforeTransformationRules1.Length;
             size = beforeProjectionPruning3.Length;
             size = beforeTransformationRules2.Length;
-            size = beforeJoinElimination1.Length;
+            size = beforeNullSemantics.Length;
             size = beforeTransformationRules3.Length;
-            size = beforeJoinElimination2.Length;
+            size = beforeJoinElimination.Length;
             size = beforeTransformationRules4.Length;
-            size = beforeNullSemantics.Length;
-            size = beforeTransformationRules5.Length;
-            size = beforeTransformationRules6.Length;
             size = beforeCodeGen.Length;
 #endif
         }

src/EntityFramework/Core/Query/PlanCompiler/TransformationRules.cs

@@ -56,9 +56,6 @@ internal static class TransformationRules
         internal static readonly ReadOnlyCollection<ReadOnlyCollection<Rule>> NullSemanticsRulesTable =
             BuildLookupTableForRules(NullSemanticsRules);
 
-        internal static readonly ReadOnlyCollection<ReadOnlyCollection<Rule>> DeferredRulesTable =
-            BuildLookupTableForRules(DeferredRules);
-
         #region private state maintenance
 
         private static List<Rule> allRules;
@@ -99,6 +96,7 @@ private static List<Rule> PostJoinEliminationRules
                     //these don't use key info per-se, but can help after the distinct op rules.
                     postJoinEliminationRules.AddRange(DistinctOpRules.Rules);
                     postJoinEliminationRules.AddRange(FilterOpRules.Rules);
+                    postJoinEliminationRules.AddRange(ApplyOpRules.Rules);
                     postJoinEliminationRules.AddRange(JoinOpRules.Rules);
                     postJoinEliminationRules.AddRange(NullabilityRules);
                 }
@@ -150,24 +148,6 @@ private static List<Rule> NullSemanticsRules
             }
         }
 
-        private static List<Rule> deferredRules;
-
-        private static List<Rule> DeferredRules
-        {
-            get
-            {
-                if (deferredRules == null)
-                {
-                    deferredRules = new List<Rule>();
-                    deferredRules.Add(FilterOpRules.Rule_FilterOverLeftOuterJoin);
-                    deferredRules.Add(FilterOpRules.Rule_FilterOverOuterApply);
-                    deferredRules.AddRange(ApplyOpRules.Rules);
-                    deferredRules.AddRange(JoinOpRules.Rules);
-                }
-                return deferredRules;
-            }
-        }
-
         private static ReadOnlyCollection<ReadOnlyCollection<Rule>> BuildLookupTableForRules(IEnumerable<Rule> rules)
         {
             var NoRules = new ReadOnlyCollection<Rule>(new Rule[0]);
@@ -254,9 +234,6 @@ internal static bool Process(PlanCompiler compilerState, TransformationRulesGrou
                 case TransformationRulesGroup.NullSemantics:
                     rulesTable = NullSemanticsRulesTable;
                     break;
-                case TransformationRulesGroup.Deferred:
-                    rulesTable = DeferredRulesTable;
-                    break;
             }
 
             // If any rule has been applied after which reapplying nullability rules may be useful,

src/EntityFramework/Core/Query/PlanCompiler/TransformationRulesGroup.cs

@@ -10,7 +10,6 @@ internal enum TransformationRulesGroup
         All,
         Project,
         PostJoinElimination,
-        NullSemantics,
-        Deferred
+        NullSemantics
     }
 }

test/EntityFramework/FunctionalTests/Query/JoinEliminationTests.cs

@@ -211,5 +211,165 @@ FROM  [dbo].[Strings] AS [Extent1]
                 QueryTestHelpers.VerifyQuery(query, expectedSqlStrings);
             }
         }
+
+        public class CodePlex2296 : FunctionalTestBase
+        {
+            public class MyBase
+            {
+                public int Id { get; set; }
+            }
+
+            public class MyDerived1 : MyBase
+            {
+                public string Name { get; set; }
+                public MyDerived2 Derived2 { get; set; }
+            }
+
+            public class MyDerived2 : MyBase
+            {
+                public string Name { get; set; }
+                public MyDerived1 Derived1 { get; set; }
+            }
+
+            public class MyContext : DbContext
+            {
+                static MyContext()
+                {
+                    Database.SetInitializer<MyContext>(null);
+                }
+
+                public DbSet<MyBase> Bases { get; set; }
+
+                protected override void OnModelCreating(DbModelBuilder builder)
+                {
+                    builder.Entity<MyBase>().ToTable("MyBase");
+                    builder.Entity<MyDerived2>().HasOptional(e => e.Derived1).WithOptionalDependent(e => e.Derived2);
+                    builder.Entity<MyDerived1>().ToTable("Derived1");
+                    builder.Entity<MyDerived2>().ToTable("Derived2");
+                }
+            }
+
+            [Fact]
+            public void Joins_are_eliminated_and_expression_is_simplified()
+            {
+                using (var context = new MyContext())
+                {
+                    var query = context.Bases.OfType<MyDerived2>().Where(e => e.Derived1.Derived2.Name == "Foo");
+
+                    QueryTestHelpers.VerifyQuery(
+                        query,
+@"SELECT 
+    [Extent1].[Id] AS [Id], 
+    '0X0X' AS [C1], 
+    [Extent1].[Name] AS [Name], 
+    CAST(NULL AS varchar(1)) AS [C2], 
+    [Extent1].[Derived1_Id] AS [Derived1_Id]
+    FROM  [dbo].[Derived2] AS [Extent1]
+    INNER JOIN [dbo].[Derived2] AS [Extent2] ON ([Extent2].[Derived1_Id] = [Extent1].[Derived1_Id]) AND ([Extent1].[Derived1_Id] IS NOT NULL)
+    WHERE ([Extent2].[Derived1_Id] IS NOT NULL) AND (N'Foo' = [Extent2].[Name])");
+                }
+            }
+        }
+
+        public class CodePlex2256 : FunctionalTestBase
+        {
+            public class A
+            {
+                public int Id { get; set; }
+
+                public B B { get; set; }
+            }
+
+            public class B
+            {
+                public B()
+                {
+                    As = new List<A>();
+                }
+
+                public int Id { get; set; }
+
+                public C C { get; set; }
+                public ICollection<A> As { get; set; } 
+            }
+
+            public class C
+            {
+                public C()
+                {
+                    Bs = new List<B>();
+                }
+
+                public int Id { get; set; }
+
+                public D D { get; set; }
+                public ICollection<B> Bs { get; set; }
+            }
+
+            public class D
+            {
+                public D()
+                {
+                    Cs = new List<C>();
+                }
+
+                public int Id { get; set; }
+
+                public E E { get; set; }
+                public ICollection<C> Cs { get; set; }
+            }
+
+            public class E
+            {
+                public E()
+                {
+                    Ds = new List<D>();
+                }
+
+                public int Id { get; set; }
+
+                public ICollection<D> Ds { get; set; }
+            }
+
+            public class MyContext : DbContext
+            {
+                static MyContext()
+                {
+                    Database.SetInitializer<MyContext>(null);
+                }
+
+                public DbSet<A> As { get; set; }
+
+                protected override void OnModelCreating(DbModelBuilder modelBuilder)
+                {
+                    modelBuilder.Entity<A>().HasRequired(e => e.B).WithMany(e => e.As);
+                    modelBuilder.Entity<B>().HasRequired(e => e.C).WithMany(e => e.Bs);
+                    modelBuilder.Entity<C>().HasRequired(e => e.D).WithMany(e => e.Cs);
+                    modelBuilder.Entity<D>().HasRequired(e => e.E).WithMany(e => e.Ds);
+                }
+            }
+
+            [Fact]
+            public void Joins_are_eliminated_and_expression_is_simplified()
+            {
+                using (var context = new MyContext())
+                {
+                    var query = context.As.Include(a => a.B.C.D.E);
+
+                    QueryTestHelpers.VerifyQuery(
+                        query,
+@"SELECT 
+    [Extent1].[Id] AS [Id], 
+    [Extent2].[Id] AS [Id1], 
+    [Extent3].[Id] AS [Id2], 
+    [Extent4].[Id] AS [Id3], 
+    [Extent4].[E_Id] AS [E_Id]
+    FROM    [dbo].[A] AS [Extent1]
+    INNER JOIN [dbo].[B] AS [Extent2] ON [Extent1].[B_Id] = [Extent2].[Id]
+    INNER JOIN [dbo].[C] AS [Extent3] ON [Extent2].[C_Id] = [Extent3].[Id]
+    INNER JOIN [dbo].[D] AS [Extent4] ON [Extent3].[D_Id] = [Extent4].[Id]");
+                }
+            }
+        }
     }
 }