Cosmos: Complex properties Query

src/EFCore.Cosmos/Extensions/Internal/CosmosShapedQueryExpressionExtensions.cs

@@ -167,9 +167,9 @@ public static bool TryExtractArray(
             projectedStructuralTypeShaper = shaper;
             projection = shaper.ValueBufferExpression;
             if (projection is ProjectionBindingExpression { ProjectionMember: { } projectionMember }
-                && select.GetMappedProjection(projectionMember) is EntityProjectionExpression entityProjection)
+                && select.GetMappedProjection(projectionMember) is StructuralTypeProjectionExpression structuralTypeProjection)
             {
-                projection = entityProjection.Object;
+                projection = structuralTypeProjection.Object;
             }
         }
         else

src/EFCore.Cosmos/Query/Internal/CosmosAliasManager.cs

@@ -226,7 +226,7 @@ protected override Expression VisitExtension(Expression node)
                 ScalarReferenceExpression reference when aliasRewritingMap.TryGetValue(reference.Name, out var newAlias)
                     => new ScalarReferenceExpression(newAlias, reference.Type, reference.TypeMapping),
                 ObjectReferenceExpression reference when aliasRewritingMap.TryGetValue(reference.Name, out var newAlias)
-                    => new ObjectReferenceExpression(reference.EntityType, newAlias),
+                    => new ObjectReferenceExpression(reference.StructuralType, newAlias),
 
                 _ => base.VisitExtension(node)
             };

src/EFCore.Cosmos/Query/Internal/CosmosProjectionBindingExpressionVisitor.cs

@@ -133,6 +133,7 @@ public virtual Expression Translate(SelectExpression selectExpression, Expressio
             var translation = _sqlTranslator.Translate(expression);
             if (translation == null)
             {
+                _selectExpression.IndicateClientProjection();
                 return base.Visit(expression);
             }
 
@@ -214,11 +215,11 @@ protected override Expression VisitExtension(Expression extensionExpression)
 
                 if (_clientEval)
                 {
-                    var entityProjection = (EntityProjectionExpression)projection;
+                    var structuralTypeProjection = (StructuralTypeProjectionExpression)projection;
 
                     return entityShaperExpression.Update(
                         new ProjectionBindingExpression(
-                            _selectExpression, _selectExpression.AddToProjection(entityProjection), typeof(ValueBuffer)));
+                            _selectExpression, _selectExpression.AddToProjection(structuralTypeProjection), typeof(ValueBuffer)));
                 }
 
                 _projectionMapping[_projectionMembers.Peek()] = projection;
@@ -303,19 +304,19 @@ protected override Expression VisitMember(MemberExpression memberExpression)
                 return NullSafeUpdate(innerExpression);
         }
 
-        var innerEntityProjection = shaperExpression.ValueBufferExpression switch
+        var innerStructuralTypeProjection = shaperExpression.ValueBufferExpression switch
         {
             ProjectionBindingExpression innerProjectionBindingExpression
-                => (EntityProjectionExpression)_selectExpression.Projection[innerProjectionBindingExpression.Index!.Value].Expression,
+                => (StructuralTypeProjectionExpression)_selectExpression.Projection[innerProjectionBindingExpression.Index!.Value].Expression,
 
-            // Unwrap EntityProjectionExpression when the root entity is not projected
+            // Unwrap StructuralTypeProjectionExpression when the root entity is not projected
             UnaryExpression unaryExpression
-                => (EntityProjectionExpression)((UnaryExpression)unaryExpression.Operand).Operand,
+                => (StructuralTypeProjectionExpression)((UnaryExpression)unaryExpression.Operand).Operand,
 
             _ => throw new InvalidOperationException(CoreStrings.TranslationFailed(memberExpression.Print()))
         };
 
-        var navigationProjection = innerEntityProjection.BindMember(
+        var navigationProjection = innerStructuralTypeProjection.BindMember(
             memberExpression.Member, innerExpression.Type, clientEval: true, out var propertyBase);
 
         if (propertyBase is not INavigation navigation
@@ -326,10 +327,10 @@ UnaryExpression unaryExpression
 
         switch (navigationProjection)
         {
-            case EntityProjectionExpression entityProjection:
+            case StructuralTypeProjectionExpression structuralTypeProjection:
                 return new StructuralTypeShaperExpression(
                     navigation.TargetEntityType,
-                    Expression.Convert(Expression.Convert(entityProjection, typeof(object)), typeof(ValueBuffer)),
+                    Expression.Convert(Expression.Convert(structuralTypeProjection, typeof(object)), typeof(ValueBuffer)),
                     nullable: true);
 
             case ObjectArrayAccessExpression objectArrayProjectionExpression:
@@ -525,16 +526,16 @@ when _collectionShaperMapping.TryGetValue(parameterExpression, out var collectio
                     return QueryCompilationContext.NotTranslatedExpression;
             }
 
-            var innerEntityProjection = shaperExpression.ValueBufferExpression switch
+            var innerStructuralTypeProjection = shaperExpression.ValueBufferExpression switch
             {
-                EntityProjectionExpression entityProjection
-                    => entityProjection,
+                StructuralTypeProjectionExpression structuralTypeProjection
+                    => structuralTypeProjection,
 
                 ProjectionBindingExpression innerProjectionBindingExpression
-                    => (EntityProjectionExpression)_selectExpression.Projection[innerProjectionBindingExpression.Index!.Value].Expression,
+                    => (StructuralTypeProjectionExpression)_selectExpression.Projection[innerProjectionBindingExpression.Index!.Value].Expression,
 
                 UnaryExpression unaryExpression
-                    => (EntityProjectionExpression)((UnaryExpression)unaryExpression.Operand).Operand,
+                    => (StructuralTypeProjectionExpression)((UnaryExpression)unaryExpression.Operand).Operand,
 
                 _ => throw new InvalidOperationException(CoreStrings.TranslationFailed(methodCallExpression.Print()))
             };
@@ -543,7 +544,7 @@ UnaryExpression unaryExpression
             var navigation = _includedNavigations.FirstOrDefault(n => n.Name == memberName);
             if (navigation == null)
             {
-                navigationProjection = innerEntityProjection.BindMember(
+                navigationProjection = innerStructuralTypeProjection.BindMember(
                     memberName, visitedSource.Type, clientEval: true, out var propertyBase);
 
                 if (propertyBase is not INavigation projectedNavigation || !projectedNavigation.IsEmbedded())
@@ -555,7 +556,7 @@ UnaryExpression unaryExpression
             }
             else
             {
-                navigationProjection = innerEntityProjection.BindNavigation(navigation, clientEval: true);
+                navigationProjection = innerStructuralTypeProjection.BindNavigation(navigation, clientEval: true);
             }
 
             switch (navigationProjection)

src/EFCore.Cosmos/Query/Internal/CosmosQuerySqlGenerator.cs

@@ -62,11 +62,11 @@ public virtual CosmosSqlQuery GetSqlQuery(
     ///     any release. You should only use it directly in your code with extreme caution and knowing that
     ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    protected override Expression VisitEntityProjection(EntityProjectionExpression entityProjectionExpression)
+    protected override Expression VisitStructuralTypeProjection(StructuralTypeProjectionExpression structuralTypeProjectionExpression)
     {
-        Visit(entityProjectionExpression.Object);
+        Visit(structuralTypeProjectionExpression.Object);
 
-        return entityProjectionExpression;
+        return structuralTypeProjectionExpression;
     }
 
     /// <summary>

src/EFCore.Cosmos/Query/Internal/CosmosQueryableMethodTranslatingExpressionVisitor.cs

@@ -252,7 +252,7 @@ protected override Expression VisitExtension(Expression extensionExpression)
                 var alias = _aliasManager.GenerateSourceAlias(fromSql);
                 var selectExpression = new SelectExpression(
                     new SourceExpression(fromSql, alias),
-                    new EntityProjectionExpression(new ObjectReferenceExpression(entityType, alias), entityType));
+                    new StructuralTypeProjectionExpression(new ObjectReferenceExpression(entityType, alias), entityType));
                 return CreateShapedQueryExpression(entityType, selectExpression) ?? QueryCompilationContext.NotTranslatedExpression;
 
             default:
@@ -300,7 +300,7 @@ protected override QueryableMethodTranslatingExpressionVisitor CreateSubqueryVis
         var alias = _aliasManager.GenerateSourceAlias("c");
         var selectExpression = new SelectExpression(
             new SourceExpression(new ObjectReferenceExpression(entityType, "root"), alias),
-            new EntityProjectionExpression(new ObjectReferenceExpression(entityType, alias), entityType));
+            new StructuralTypeProjectionExpression(new ObjectReferenceExpression(entityType, alias), entityType));
 
         // Add discriminator predicate
         var concreteEntityTypes = entityType.GetConcreteDerivedTypesInclusive().ToList();
@@ -323,7 +323,7 @@ protected override QueryableMethodTranslatingExpressionVisitor CreateSubqueryVis
                 "Missing discriminator property in hierarchy");
             if (discriminatorProperty is not null)
             {
-                var discriminatorColumn = ((EntityProjectionExpression)selectExpression.GetMappedProjection(new ProjectionMember()))
+                var discriminatorColumn = ((StructuralTypeProjectionExpression)selectExpression.GetMappedProjection(new ProjectionMember()))
                     .BindProperty(discriminatorProperty, clientEval: false);
 
                 var success = TryApplyPredicate(
@@ -340,9 +340,9 @@ protected override QueryableMethodTranslatingExpressionVisitor CreateSubqueryVis
         return CreateShapedQueryExpression(entityType, selectExpression);
     }
 
-    private ShapedQueryExpression? CreateShapedQueryExpression(IEntityType entityType, SelectExpression queryExpression)
+    private ShapedQueryExpression? CreateShapedQueryExpression(ITypeBase structuralType, SelectExpression queryExpression)
     {
-        if (!entityType.IsOwned())
+        if (structuralType is IEntityType entityType && !entityType.IsOwned())
         {
             var existingEntityType = _queryCompilationContext.RootEntityType;
             if (existingEntityType is not null && existingEntityType != entityType)
@@ -358,7 +358,7 @@ protected override QueryableMethodTranslatingExpressionVisitor CreateSubqueryVis
         return new ShapedQueryExpression(
             queryExpression,
             new StructuralTypeShaperExpression(
-                entityType,
+                structuralType,
                 new ProjectionBindingExpression(queryExpression, new ProjectionMember(), typeof(ValueBuffer)),
                 nullable: false));
     }
@@ -532,6 +532,14 @@ protected override ShapedQueryExpression TranslateCast(ShapedQueryExpression sou
             return null;
         }
 
+        // We can not apply distinct because SQL DISTINCT operates on the full
+        // structural type, but the shaper extracts only a subset of that data.
+        // Cosmos: Projecting out nested documents retrieves the entire document #34067
+        if (select.UsesClientProjection)
+        {
+            return null;
+        }
+
         select.ApplyDistinct();
 
         return source;
@@ -607,7 +615,7 @@ protected override ShapedQueryExpression TranslateCast(ShapedQueryExpression sou
 
                 var translatedSelect =
                     new SelectExpression(
-                        new EntityProjectionExpression(translation, (IEntityType)projectedStructuralTypeShaper.StructuralType));
+                        new StructuralTypeProjectionExpression(translation, projectedStructuralTypeShaper.StructuralType));
                 return source.Update(
                     translatedSelect,
                     new StructuralTypeShaperExpression(
@@ -859,24 +867,19 @@ protected override ShapedQueryExpression TranslateCast(ShapedQueryExpression sou
     /// </summary>
     protected override ShapedQueryExpression? TranslateOfType(ShapedQueryExpression source, Type resultType)
     {
-        if (source.ShaperExpression is not StructuralTypeShaperExpression entityShaperExpression)
+        if (source.ShaperExpression is not StructuralTypeShaperExpression { StructuralType: IEntityType entityType } shaper)
         {
             return null;
         }
 
-        if (entityShaperExpression.StructuralType is not IEntityType entityType)
-        {
-            throw new UnreachableException("Complex types not supported in Cosmos");
-        }
-
         if (entityType.ClrType == resultType)
         {
             return source;
         }
 
         var select = (SelectExpression)source.QueryExpression;
 
-        var parameterExpression = Expression.Parameter(entityShaperExpression.Type);
+        var parameterExpression = Expression.Parameter(shaper.Type);
         var predicate = Expression.Lambda(Expression.TypeIs(parameterExpression, resultType), parameterExpression);
 
         if (!TryApplyPredicate(source, predicate))
@@ -887,23 +890,23 @@ protected override ShapedQueryExpression TranslateCast(ShapedQueryExpression sou
         var baseType = entityType.GetAllBaseTypes().SingleOrDefault(et => et.ClrType == resultType);
         if (baseType != null)
         {
-            return source.UpdateShaperExpression(entityShaperExpression.WithType(baseType));
+            return source.UpdateShaperExpression(shaper.WithType(baseType));
         }
 
         var derivedType = entityType.GetDerivedTypes().Single(et => et.ClrType == resultType);
-        var projectionBindingExpression = (ProjectionBindingExpression)entityShaperExpression.ValueBufferExpression;
+        var projectionBindingExpression = (ProjectionBindingExpression)shaper.ValueBufferExpression;
 
         var projectionMember = projectionBindingExpression.ProjectionMember;
         Check.DebugAssert(new ProjectionMember().Equals(projectionMember), "Invalid ProjectionMember when processing OfType");
 
-        var entityProjectionExpression = (EntityProjectionExpression)select.GetMappedProjection(projectionMember);
+        var structuralTypeProjectionExpression = (StructuralTypeProjectionExpression)select.GetMappedProjection(projectionMember);
         select.ReplaceProjectionMapping(
             new Dictionary<ProjectionMember, Expression>
             {
-                { projectionMember, entityProjectionExpression.UpdateEntityType(derivedType) }
+                    { projectionMember, structuralTypeProjectionExpression.UpdateEntityType(derivedType) }
             });
 
-        return source.UpdateShaperExpression(entityShaperExpression.WithType(derivedType));
+        return source.UpdateShaperExpression(shaper.WithType(derivedType));
     }
 
     /// <summary>
@@ -1131,9 +1134,9 @@ protected override ShapedQueryExpression TranslateSelect(ShapedQueryExpression s
                 var translatedSelect = SelectExpression.CreateForCollection(
                     slice,
                     alias,
-                    new EntityProjectionExpression(
-                        new ObjectReferenceExpression((IEntityType)projectedStructuralTypeShaper.StructuralType, alias),
-                        (IEntityType)projectedStructuralTypeShaper.StructuralType));
+                    new StructuralTypeProjectionExpression(
+                        new ObjectReferenceExpression(projectedStructuralTypeShaper.StructuralType, alias),
+                        projectedStructuralTypeShaper.StructuralType));
                 return source.Update(
                     translatedSelect,
                     new StructuralTypeShaperExpression(
@@ -1270,9 +1273,9 @@ protected override ShapedQueryExpression TranslateSelect(ShapedQueryExpression s
                 var translatedSelect = SelectExpression.CreateForCollection(
                     slice,
                     alias,
-                    new EntityProjectionExpression(
-                        new ObjectReferenceExpression((IEntityType)projectedStructuralTypeShaper.StructuralType, alias),
-                        (IEntityType)projectedStructuralTypeShaper.StructuralType));
+                    new StructuralTypeProjectionExpression(
+                        new ObjectReferenceExpression(projectedStructuralTypeShaper.StructuralType, alias),
+                        projectedStructuralTypeShaper.StructuralType));
                 return source.Update(
                     translatedSelect,
                     new StructuralTypeShaperExpression(
@@ -1361,7 +1364,7 @@ protected override ShapedQueryExpression TranslateSelect(ShapedQueryExpression s
     /// </summary>
     protected override ShapedQueryExpression? TranslateMemberAccess(Expression source, MemberIdentity member)
     {
-        // Attempt to translate access into a primitive collection property
+        // Attempt to translate access into a primitive, complex or embedded owned navigation collection property
         if (_sqlTranslator.TryBindMember(
                 _sqlTranslator.Visit(source),
                 member,
@@ -1378,20 +1381,19 @@ protected override ShapedQueryExpression TranslateSelect(ShapedQueryExpression s
 
             switch (translatedExpression)
             {
-                case StructuralTypeShaperExpression shaper when property is INavigation { IsCollection: true }:
+                case StructuralTypeShaperExpression shaper when property is INavigation { IsCollection: true }
+                                                                         or IComplexProperty { IsCollection: true }:
                 {
-                    var targetEntityType = (IEntityType)shaper.StructuralType;
-                    var projection = new EntityProjectionExpression(
-                        new ObjectReferenceExpression(targetEntityType, sourceAlias), targetEntityType);
+                    var targetStructuralType = shaper.StructuralType;
+                    var projection = new StructuralTypeProjectionExpression(
+                        new ObjectReferenceExpression(targetStructuralType, sourceAlias), targetStructuralType);
                     var select = SelectExpression.CreateForCollection(
                         shaper.ValueBufferExpression,
                         sourceAlias,
                         projection);
-                    return CreateShapedQueryExpression(targetEntityType, select);
+                    return CreateShapedQueryExpression(targetStructuralType, select);
                 }
 
-                // TODO: Collection of complex type (#31253)
-
                 // Note that non-collection navigations/complex types are handled in CosmosSqlTranslatingExpressionVisitor
                 // (no collection -> no queryable operators)
 
@@ -1666,7 +1668,7 @@ private bool TryPushdownIntoSubquery(SelectExpression select)
                 var translation = new ObjectFunctionExpression(functionName, [array1, array2], arrayType);
                 var alias = _aliasManager.GenerateSourceAlias(translation);
                 var select = SelectExpression.CreateForCollection(
-                    translation, alias, new ObjectReferenceExpression((IEntityType)structuralType1, alias));
+                    translation, alias, new ObjectReferenceExpression(structuralType1, alias));
                 return CreateShapedQueryExpression(select, structuralType1.ClrType);
             }
         }