Translation skipped for array accessed by relationship

[AlenitsynMM]

While operation translations for simple types on owned entities are working well, array operations aren't getting translated into sql query.

public class Entity
{
 public int Id { get; set; }
 public OwnedEntity OwnedEntity { get; set; }
}

public class OwnedEntity
{
 public int[] Array { get; set; }
}

Configuration:

modelBuilder.Entity<Entity>(
 builder =>
 {
 builder.HasKey(s => s.Id);
 builder.OwnsOne(
 s => s.OwnedEntity,
 ownershipBuilder =>
 {
 ownershipBuilder
 .Property(entity => entity.Array)
 .IsRequired();
 });
 });

LINQ:

context.Set<Entity>()
 .Where(s => s.OwnedEntity.Array.Contains(1))
 .ToList();

Actual sql query:

SELECT s."Id", s."Id", s."OwnedEntity_Array"
FROM "Entity" AS s

Expected sql query:

SELECT s."Id", s."OwnedEntity_Array"
FROM "Entity" AS s
WHERE 1 = ANY (s."OwnedEntity_Array") = TRUE

Actual for: Npgsql.EntityFrameworkCore.PostgreSQL v2.2.0-preview1

[roji]

This is actually unrelated to owned entities and can be reproduced with a regular one-to-one relationship as shown below. Seems like when an array property is accessed by traversing a relationship, for some reason we fail to translate to SQL.

@austindrenski I think you worked in these waters before, interested in taking a look? I won't have time to dive into this in the coming weeks...

class Program
{
 static void Main(string[] args)
 {
 using (var ctx = new BlogContext())
 {
 ctx.Database.EnsureDeleted();
 ctx.Database.EnsureCreated();

 // Produces good query:
 // SELECT s."Id", s."Array"
 // FROM "Posts" AS s
 // WHERE 1 = ANY (s."Array") = TRUE
 var posts1 = ctx.Posts
 .Where(s => s.Array.Contains(1))
 .ToList();

 // Produces bad query:
 // SELECT s."Id", s."PostId", "s.Post"."Array"
 // FROM "Blogs" AS s
 // LEFT JOIN "Posts" AS "s.Post" ON s."PostId" = "s.Post"."Id"
 var posts2 = ctx.Blogs
 .Where(s => s.Post.Array.Contains(1))
 .ToList();
 }
 }
}

public class Blog
{
 public int Id { get; set; }
 public Post Post { get; set; }
}

public class Post
{
 public int Id { get; set; }
 public int[] Array { get; set; }
}

public class BlogContext : DbContext
{
 public const string ConnectionString = "Host=localhost;Database=test;Username=npgsql_tests;Password=npgsql_tests";

 public DbSet<Blog> Blogs { get; set; }
 public DbSet<Post> Posts { get; set; }

 protected override void OnConfiguring(DbContextOptionsBuilder builder)
 => builder.UseNpgsql(ConnectionString);
}

[roji]

Moving this to the backlog, @austindrenski you may be interested in this.

[austindrenski]

Yes, still interested... I need to wrap up a few more issues for 2.2 first, then I'll give this a look. It may also be worth waiting for #541 to merge, since that has an effect on how array translations evaluate.

[austindrenski]

I can reproduce this with the test suite for hotfix/2.1.3 (cbbd243). Troubleshooting now.

I cannot reproduce this with the test suite for dev (4441b26). So this should be fixed in version 2.2.0.

@roji Any ideas on what changed since 2.1 in this area?

Tests

[Fact]
public void Contains_with_navigation_property()
{
 using (var ctx = Fixture.CreateContext())
 {
 var _ = ctx.SomeEntities.Where(e => e.SomeRelatedEntity.SomeArray.Contains(3)).ToList();

 AssertContainsInSql("WHERE 3 = ANY (\"e.SomeRelatedEntity\".\"SomeArray\") = TRUE");
 }
}

public class SomeArrayEntity
{
 public int Id { get; set; }
 public int[] SomeArray { get; set; }
 public int[,] SomeMatrix { get; set; }
 public List<int> SomeList { get; set; }
 public byte[] SomeBytea { get; set; }
 public string SomeText { get; set; }
 public SomeRelatedEntity SomeRelatedEntity { get; set; }
}

public class SomeRelatedEntity
{
 public int Id { get; set; }
 public int[] SomeArray { get; set; }
}

-- full query output (formatted for clarity):

SELECT 
 e."Id", 
 e."SomeArray", 
 e."SomeBytea", 
 e."SomeList", 
 e."SomeMatrix", 
 e."SomeRelatedEntityId", 
 e."SomeText"

FROM "SomeEntities" AS e

LEFT JOIN "SomeRelatedEntities" AS "e.SomeRelatedEntity" 
 ON e."SomeRelatedEntityId" = "e.SomeRelatedEntity"."Id"

WHERE 3 = ANY ("e.SomeRelatedEntity"."SomeArray") = TRUE

[austindrenski]

Debugging in hotfix/2.1.3 shows that the issue is due to the navigation property being wrapped in a NullConditionalExpression, causing MemberAccessBindingExpressionVisitor.GetPropertyPath(...) to return no properties (i.e. properties.Count == 0).

GetPropertyPath(...) was updated for 2.2.0 to unwrap the NullConditionalExpression. It appears this was done to support owned navigations for CosmosDB.

---

---

We could simply unwrap NullConditionalExpression, but I'm a bit hesitant to do that because it's located in Microsoft.EntityFrameworkCore.Query.Expressions.Internal.

This does pass the test suite, but just feels a little too risky for a patch release:

var subQueryModel = expression.QueryModel;
var fromExpression = subQueryModel.MainFromClause.FromExpression;

// unwrap and move on
if (fromExpression is NullConditionalExpression n)
 fromExpression = n.AccessOperation;

@roji Any thoughts on this?

[roji]

@austindrenski thanks for deep-diving into this and for the good analysis!

I agree with everything you're saying... If the bug no longer exists in 2.2 (which is about to be released), I don't see any reason to introduce a risky fix in a 2.1 patch release... Our answer here should probably be to just upgrade to 2.2.

From my side feel free to close this issue, unless you have other thoughts...