False positive when using Any on nested array

[SapiensAnatis]

Version: 0.7.3

Hey, thank you for your work on this library. It's really simplified an app I'm making to store active co-op games.

I hit a little bit of a snag trying to index a sub-array of my object. It seems like my query is returning true when I don't want it to. I put together this minimal example:

using Redis.OM;
using Redis.OM.Modeling;

var provider = new RedisConnectionProvider("redis://localhost:6379");
provider.Connection.CreateIndex(typeof(Game));

var collection = provider.RedisCollection<Game>();

if (collection.FindById("1") is { } game)
    collection.Delete(game);

collection.Insert(new Game()
{
    Id = 1,
    Players =
    [
        new Player()
        {
            Id = 1,
            ActorNr = 1,
        },
        new Player()
        {
            Id = 2,
            ActorNr = 2,
        }
    ]
});
collection.Save();

Console.WriteLine($"Player 1 is host: {await CheckIsHost(1)}");
Console.WriteLine($"Player 2 is host: {await CheckIsHost(2)}");

async Task<bool> CheckIsHost(int id)
{
    return await collection.AnyAsync(x => x.Players.Any(y => y.Id == id && y.ActorNr == 1));
}

[Document(StorageType = StorageType.Json)]
public class Game
{
    [RedisIdField] 
    public int Id { get; set; }
    
    [Indexed(JsonPath = $"$.{nameof(Player.Id)}")]
    [Indexed(JsonPath = $"$.{nameof(Player.ActorNr)}")]
    public List<Player> Players { get; set; } = [];
}

public class Player
{
    [Indexed]
    public int Id { get; set; }
    
    [Indexed]
    public int ActorNr { get; set; }
}

What I want to do with the AnyAsync is test if a particular ID is hosting a game - that is, that there exists a game with a player whose ID is 1 AND whose actor number is 1. But when I run that program I get:

Player 1 is host: True
Player 2 is host: True

I would expect:

Player 1 is host: True
Player 2 is host: False

The queries that redis-om is running (according to monitor) are

"FT.SEARCH" "game-idx" "((@Players_Id:[1 1]) (@Players_ActorNr:[1 1]))" "LIMIT" "0" "0"
"FT.SEARCH" "game-idx" "((@Players_Id:[2 2]) (@Players_ActorNr:[1 1]))" "LIMIT" "0" "0"

My knowledge of RediSearch is quite lacking, but I believe that is searching for any game that has a player with an actor number of 1, and that has a player with an actor number of 2. These could be two different players, so I don't think it really satisfies the LINQ expression I wrote. Unfortunately I'm not good enough with RediSearch to know what the correct query is here.

I have been able to work around this issue by loading all games onto the client and doing my filtering in .NET, which is fine for my use case as it is not a huge amount of data. But I thought it would be best to raise this as it seems like a probable bug.

[slorello89]

Hi @SapiensAnatis - yeah this is frustratingly both:

1. The expected query & result for Redis OM + RediSearch
2. Inconsistent with what you would expect from that LINQ query

RediSearch allows you to index any field that is either:

1. A scalar
2. resolves to an array of scalars

Which of course you are taking advantage of here. The filters however only tell you whether a given record matches the filter. So in your case here, both of those records match the filter. in case one there IS an ID in $.Players.Id[*] who's ID is one and there IS a ActorNr in $.Players.ActorNr[*] of one. And then the same in the second case. Let's take a look at those JSON paths resolved on your game key:

JSON.GET Game:1 $.Players[*].Id
"[1,2]"
JSON.GET Game:1 $.Players[*].ActorNr
"[1,2]"

that's what you are going to be matching against, it's not running a full filter to ensure there's an individual player that matches all the criteria, just that there is a player that matches each of the criteria.

[SapiensAnatis]

Thanks for the explanation @slorello89 - based on the research I had done into RediSearch I had a feeling it wasn’t quite possible to translate that expression, but I didn’t want to say so for sure.

Would it be an idea for the library to throw an exception stating it can’t translate the expression in this case? This is something that Entity Framework Core does quite often when it encounters an expression tree construct that can’t be converted into SQL. It would have definitely saved me some debugging, as the expression did appear to be working correctly when initially I only had one player in the list.

[slorello89]

Hmm, I'd be hesitant to do that, this behavior has been in Redis OM .NET and RediSearch for some time now, so while it's a little quirky, my guess is that the quirk is load-bearing somewhere. A better route is probably to just add to the FAQ/README.

[SapiensAnatis]

Yeah, I can understand your reluctance to change this behaviour if it’s already shipped. Documentation would be good.

I wonder if it’s possible to make an analyzer that could warn about queries that are likely to exhibit this behaviour?

[slorello89]

added some commentary to the readme in #467 to address this, so I'm going to go ahead and close this issue.