Query: Throw exception for null key value in non-tracking

Resolves #26310
dotnet · Oct 27, 2021 · 69651a8 · 69651a8
1 parent 2d2fcdc
commit 69651a8
Show file tree

Hide file tree

Showing 2 changed files with 76 additions and 3 deletions.
diff --git a/src/EFCore/Query/ShapedQueryCompilingExpressionVisitor.cs b/src/EFCore/Query/ShapedQueryCompilingExpressionVisitor.cs
@@ -8,6 +8,7 @@
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore.ChangeTracking.Internal;
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -324,6 +325,9 @@ private static readonly MethodInfo _startTrackingMethodInfo
                 = typeof(QueryContext).GetRequiredMethod(
                     nameof(QueryContext.StartTracking), typeof(IEntityType), typeof(object), typeof(ValueBuffer));
 
+            private static readonly MethodInfo _createNullKeyValueInNoTrackingQuery
+                = typeof(EntityMaterializerInjectingExpressionVisitor).GetRequiredDeclaredMethod(nameof(CreateNullKeyValueInNoTrackingQuery));
+
             private readonly IEntityMaterializerSource _entityMaterializerSource;
             private readonly QueryTrackingBehavior _queryTrackingBehavior;
             private readonly bool _queryStateMananger;
@@ -458,16 +462,47 @@ private Expression ProcessEntityShaper(EntityShaperExpression entityShaperExpres
                 {
                     if (primaryKey != null)
                     {
-                        expressions.Add(
-                            Expression.IfThen(
-                                primaryKey.Properties.Select(
+                        if (entityShaperExpression.IsNullable)
+                        {
+                            expressions.Add(
+                                Expression.IfThen(
+                                    primaryKey.Properties.Select(
                                         p => Expression.NotEqual(
                                             valueBufferExpression.CreateValueBufferReadValueExpression(typeof(object), p.GetIndex(), p),
                                             Expression.Constant(null)))
                                     .Aggregate((a, b) => Expression.AndAlso(a, b)),
                                 MaterializeEntity(
                                     entityShaperExpression, materializationContextVariable, concreteEntityTypeVariable, instanceVariable,
                                     null)));
+                        }
+                        else
+                        {
+                            var keyValuesVariable = Expression.Variable(typeof(object[]), "keyValues" + _currentEntityIndex);
+                            expressions.Add(
+                                Expression.IfThenElse(
+                                    primaryKey.Properties.Select(
+                                        p => Expression.NotEqual(
+                                            valueBufferExpression.CreateValueBufferReadValueExpression(typeof(object), p.GetIndex(), p),
+                                            Expression.Constant(null)))
+                                    .Aggregate((a, b) => Expression.AndAlso(a, b)),
+                                MaterializeEntity(
+                                    entityShaperExpression, materializationContextVariable, concreteEntityTypeVariable, instanceVariable,
+                                    null),
+                                Expression.Block(
+                                    new[] { keyValuesVariable },
+                                    Expression.Assign(
+                                        keyValuesVariable,
+                                        Expression.NewArrayInit(
+                                            typeof(object),
+                                            primaryKey.Properties.Select(
+                                                p => valueBufferExpression.CreateValueBufferReadValueExpression(typeof(object), p.GetIndex(), p)))),
+                                    Expression.Call(
+                                        _createNullKeyValueInNoTrackingQuery,
+                                        Expression.Constant(entityType),
+                                        Expression.Constant(primaryKey.Properties),
+                                        keyValuesVariable))));
+
+                        }
                     }
                     else
                     {
@@ -605,6 +640,26 @@ private BlockExpression CreateFullMaterializeExpression(
 
                 return Expression.Block(blockExpressions);
             }
+
+            [UsedImplicitly]
+            private static Exception CreateNullKeyValueInNoTrackingQuery(
+                IEntityType entityType, IReadOnlyList<IProperty> properties, object?[] keyValues)
+            {
+                var index = -1;
+                for (var i = 0; i < keyValues.Length; i++)
+                {
+                    if (keyValues[i] == null)
+                    {
+                        index = i;
+                        break;
+                    }
+                }
+
+                var property = properties[index];
+
+                throw new InvalidOperationException(
+                    CoreStrings.InvalidKeyValue(entityType.DisplayName(), property.Name));
+            }
         }
     }
 }
diff --git a/test/EFCore.Cosmos.FunctionalTests/Query/FromSqlQueryCosmosTest.cs b/test/EFCore.Cosmos.FunctionalTests/Query/FromSqlQueryCosmosTest.cs
@@ -612,6 +612,24 @@ public virtual async Task FromSqlRaw_queryable_simple_projection_not_composed(bo
 ) c");
         }
 
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public async Task FromSqlRaw_queryable_simple_with_missing_key_and_non_tracking_throws(bool async)
+        {
+            using var context = CreateContext();
+            var query = context.Set<Customer>()
+                .FromSqlRaw(@"SELECT * FROM root c WHERE c[""Discriminator""] = ""Category""")
+                .AsNoTracking();
+            var exception = async
+                ? await Assert.ThrowsAsync<InvalidOperationException>(() => query.ToArrayAsync())
+                : Assert.Throws<InvalidOperationException>(() => query.ToArray());
+
+            Assert.Equal(CoreStrings.InvalidKeyValue(
+                context.Model.FindEntityType(typeof(Customer))!.DisplayName(),
+                "CustomerID"),
+                exception.Message);
+        }
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);