From 94cb8f3caee518a2e4ddd45c4df376ea936b6359 Mon Sep 17 00:00:00 2001
From: Smit Patel <smitpatel@users.noreply.github.com>
Date: Wed, 28 Aug 2019 15:54:02 -0700
Subject: [PATCH] InMemory: Support for DefaultIfEmpty

Part of #16963
---
 .../Query/Internal/InMemoryQueryExpression.cs | 56 ++++++++++++++++++-
 ...yableMethodTranslatingExpressionVisitor.cs | 12 +++-
 src/EFCore/Query/EntityMaterializerSource.cs  |  2 +-
 .../Query/AsyncSimpleQueryInMemoryTest.cs     | 36 ------------
 .../Query/SimpleQueryInMemoryTest.cs          | 55 +++---------------
 5 files changed, 76 insertions(+), 85 deletions(-)

diff --git a/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs b/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs
index 542d58dcc93..5de9275fde9 100644
--- a/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs
+++ b/src/EFCore.InMemory/Query/Internal/InMemoryQueryExpression.cs
@@ -252,7 +252,61 @@ public virtual void PushdownIntoSubquery()
             }
         }
 
-        private IPropertyBase InferPropertyFromInner(Expression expression)
+        public virtual void ApplyDefaultIfEmpty()
+        {
+            if (_valueBufferSlots.Count != 0)
+            {
+                throw new InvalidOperationException("Cannot Apply DefaultIfEmpty after ClientProjection.");
+            }
+
+            var result = new Dictionary<ProjectionMember, Expression>();
+            foreach (var keyValuePair in _projectionMapping)
+            {
+                if (keyValuePair.Value is EntityProjectionExpression entityProjection)
+                {
+                    var map = new Dictionary<IProperty, Expression>();
+                    foreach (var property in GetAllPropertiesInHierarchy(entityProjection.EntityType))
+                    {
+                        var index = AddToProjection(entityProjection.BindProperty(property));
+                        map[property] = CreateReadValueExpression(property.ClrType.MakeNullable(), index, property);
+                    }
+                    result[keyValuePair.Key] = new EntityProjectionExpression(entityProjection.EntityType, map);
+                }
+                else
+                {
+                    var index = AddToProjection(keyValuePair.Value);
+                    result[keyValuePair.Key] = CreateReadValueExpression(
+                        keyValuePair.Value.Type.MakeNullable(), index, InferPropertyFromInner(keyValuePair.Value));
+                }
+            }
+
+            _projectionMapping = result;
+
+            var selectorLambda = Lambda(
+                New(
+                    _valueBufferConstructor,
+                    NewArrayInit(
+                        typeof(object),
+                        _valueBufferSlots
+                            .Select(e => e.Type.IsValueType ? Convert(e, typeof(object)) : e))),
+                CurrentParameter);
+
+            _groupingParameter = null;
+
+            ServerQueryExpression = Call(
+                InMemoryLinqOperatorProvider.Select.MakeGenericMethod(ServerQueryExpression.Type.TryGetSequenceType(), typeof(ValueBuffer)),
+                ServerQueryExpression,
+                selectorLambda);
+
+            ServerQueryExpression = Call(
+                InMemoryLinqOperatorProvider.DefaultIfEmptyWithArgument.MakeGenericMethod(typeof(ValueBuffer)),
+                ServerQueryExpression,
+                New(_valueBufferConstructor, NewArrayInit(typeof(object), Enumerable.Repeat(Constant(null), _valueBufferSlots.Count))));
+
+            _valueBufferSlots.Clear();
+        }
+
+        private static IPropertyBase InferPropertyFromInner(Expression expression)
         {
             if (expression is MethodCallExpression methodCallExpression
                 && methodCallExpression.Method.IsGenericMethod
diff --git a/src/EFCore.InMemory/Query/Internal/InMemoryQueryableMethodTranslatingExpressionVisitor.cs b/src/EFCore.InMemory/Query/Internal/InMemoryQueryableMethodTranslatingExpressionVisitor.cs
index 7329a3e2b16..1944ed1f7ff 100644
--- a/src/EFCore.InMemory/Query/Internal/InMemoryQueryableMethodTranslatingExpressionVisitor.cs
+++ b/src/EFCore.InMemory/Query/Internal/InMemoryQueryableMethodTranslatingExpressionVisitor.cs
@@ -184,7 +184,17 @@ protected override ShapedQueryExpression TranslateCount(ShapedQueryExpression so
         }
 
         protected override ShapedQueryExpression TranslateDefaultIfEmpty(ShapedQueryExpression source, Expression defaultValue)
-            => null;
+        {
+            if (defaultValue == null)
+            {
+                ((InMemoryQueryExpression)source.QueryExpression).ApplyDefaultIfEmpty();
+                source.ShaperExpression = MarkShaperNullable(source.ShaperExpression);
+
+                return source;
+            }
+
+            return null;
+        }
 
         protected override ShapedQueryExpression TranslateDistinct(ShapedQueryExpression source)
         {
diff --git a/src/EFCore/Query/EntityMaterializerSource.cs b/src/EFCore/Query/EntityMaterializerSource.cs
index 76b5b77c263..d4cbb842cac 100644
--- a/src/EFCore/Query/EntityMaterializerSource.cs
+++ b/src/EFCore/Query/EntityMaterializerSource.cs
@@ -52,7 +52,7 @@ public static readonly MethodInfo TryReadValueMethod
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static TValue TryReadValue<TValue>(
             in ValueBuffer valueBuffer, int index, IPropertyBase property)
-            => (TValue)valueBuffer[index];
+            => valueBuffer[index] is TValue value ? value : default;
 
         public virtual Expression CreateMaterializeExpression(
             IEntityType entityType,
diff --git a/test/EFCore.InMemory.FunctionalTests/Query/AsyncSimpleQueryInMemoryTest.cs b/test/EFCore.InMemory.FunctionalTests/Query/AsyncSimpleQueryInMemoryTest.cs
index 386bec964c3..295108eb638 100644
--- a/test/EFCore.InMemory.FunctionalTests/Query/AsyncSimpleQueryInMemoryTest.cs
+++ b/test/EFCore.InMemory.FunctionalTests/Query/AsyncSimpleQueryInMemoryTest.cs
@@ -13,41 +13,5 @@ public AsyncSimpleQueryInMemoryTest(NorthwindQueryInMemoryFixture<NoopModelCusto
             : base(fixture)
         {
         }
-
-        [ConditionalFact(Skip = "Issue #16963 Set Operation")]
-        public override Task Concat_dbset()
-        {
-            return Task.CompletedTask;
-        }
-
-        [ConditionalFact(Skip = "Issue #16963 Set Operation")]
-        public override Task Concat_simple()
-        {
-            return Task.CompletedTask;
-        }
-
-        [ConditionalFact(Skip = "Issue #16963 Set Operation")]
-        public override Task Concat_non_entity()
-        {
-            return Task.CompletedTask;
-        }
-
-        [ConditionalFact(Skip = "Issue #16963 Set Operation")]
-        public override Task Except_non_entity()
-        {
-            return Task.CompletedTask;
-        }
-
-        [ConditionalFact(Skip = "Issue #16963 Set Operation")]
-        public override Task Intersect_non_entity()
-        {
-            return Task.CompletedTask;
-        }
-
-        [ConditionalFact(Skip = "Issue #16963 Set Operation")]
-        public override Task Union_non_entity()
-        {
-            return Task.CompletedTask;
-        }
     }
 }
diff --git a/test/EFCore.InMemory.FunctionalTests/Query/SimpleQueryInMemoryTest.cs b/test/EFCore.InMemory.FunctionalTests/Query/SimpleQueryInMemoryTest.cs
index 3f97e8fda86..b643a6ffa45 100644
--- a/test/EFCore.InMemory.FunctionalTests/Query/SimpleQueryInMemoryTest.cs
+++ b/test/EFCore.InMemory.FunctionalTests/Query/SimpleQueryInMemoryTest.cs
@@ -159,80 +159,43 @@ public override Task Projection_when_arithmetic_mixed_subqueries(bool isAsync)
             return base.Projection_when_arithmetic_mixed_subqueries(isAsync);
         }
 
-        #region DefaultIfEmpty
-
-        public override Task DefaultIfEmpty_in_subquery(bool isAsync)
-        {
-            return Task.CompletedTask;
-        }
-
-        public override Task DefaultIfEmpty_in_subquery_nested(bool isAsync)
-        {
-            return Task.CompletedTask;
-        }
-
-        public override Task DefaultIfEmpty_in_subquery_not_correlated(bool isAsync)
-        {
-            return Task.CompletedTask;
-        }
-
-        public override void DefaultIfEmpty_without_group_join()
-        {
-        }
+        #region SelectMany
 
-        public override Task Default_if_empty_top_level(bool isAsync)
+        public override Task SelectMany_Joined_DefaultIfEmpty(bool isAsync)
         {
             return Task.CompletedTask;
         }
 
-        public override Task Default_if_empty_top_level_followed_by_projecting_constant(bool isAsync)
+        public override Task SelectMany_Joined_DefaultIfEmpty2(bool isAsync)
         {
             return Task.CompletedTask;
         }
 
-        public override Task Default_if_empty_top_level_positive(bool isAsync)
+        public override Task SelectMany_correlated_with_outer_3(bool isAsync)
         {
             return Task.CompletedTask;
         }
 
-        public override Task Default_if_empty_top_level_projection(bool isAsync)
+        public override Task SelectMany_correlated_with_outer_4(bool isAsync)
         {
             return Task.CompletedTask;
         }
 
-        public override Task Join_with_default_if_empty_on_both_sources(bool isAsync)
-        {
-            return Task.CompletedTask;
-        }
         #endregion
 
-        #region SelectMany
-
-        public override Task SelectMany_Joined_DefaultIfEmpty(bool isAsync)
-        {
-            return Task.CompletedTask;
-        }
-
-        public override Task SelectMany_Joined_DefaultIfEmpty2(bool isAsync)
-        {
-            return Task.CompletedTask;
-        }
+        #region NullableError
 
-        public override Task SelectMany_correlated_with_outer_3(bool isAsync)
+        public override Task Project_single_element_from_collection_with_OrderBy_Distinct_and_FirstOrDefault_followed_by_projecting_length(bool isAsync)
         {
             return Task.CompletedTask;
         }
 
-        public override Task SelectMany_correlated_with_outer_4(bool isAsync)
+        public override Task DefaultIfEmpty_in_subquery_nested(bool isAsync)
         {
             return Task.CompletedTask;
         }
 
-        #endregion
-
-        #region NullableError
-
-        public override Task Project_single_element_from_collection_with_OrderBy_Distinct_and_FirstOrDefault_followed_by_projecting_length(bool isAsync)
+        public override Task Default_if_empty_top_level_projection(bool isAsync)
         {
             return Task.CompletedTask;
         }