如何将LINQ查询写入SQL IN

Question

I want to query my cosmosDB to get List of Documents of type ZonesDO && whose id are in UserPreferance.Zones My UserPreferance class is :

public class UserPreference 
    {
        [JsonProperty("zones")]
        public List<Zone> Zones { get; set; }
    }

and Zone Class is:

public class Zone
    {
        [JsonProperty("id")]
        public override Guid Id { get; set; }

        [JsonProperty("name")]
        public string Name { get; set; }

        [JsonProperty("category")]
        public string Category { get; set; }
    }

I am trying this query but not able to complete it.

var zones = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri)
     .Where(z => z.Type == typeof(ZoneDO).ToString() && 
     *z.Id in user.UserPreference.Zones.ids*)// here I need the solution
     .AsEnumerable().ToList();

Answer 1

You can try to use Contain method.

 var zones = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri)
     .Where(z => z.Type == typeof(ZoneDO).ToString() && 
      user.UserPreference.Zones.Select(x => x.Id).Contain(z.Id)).ToList();

Or you can use inline Where and Count

var zones = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri)
     .Where(
        z => z.Type == typeof(ZoneDO).ToString() && 
        user.UserPreference.Zones.Where(a=> a.Id == z.Id).Count() > 0
      ).ToList();

Answer 2

Perform select on Zones.Id and then check with Contains to get desired result

var zones = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri)
     .Where(z => z.Type == typeof(ZoneDO).ToString() && 
    user.UserPreference.Zones.Select(x => x.Id).Contains(z.Id))
     .AsEnumerable().ToList();

Answer 3

Another option may be to use the Any() operator:

var zones = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri)
            .Where(z => z.Type == typeof(ZoneDO).ToString() && 
            user.UserPreference.Zones.Where(x => x.Id == z.Id).Any())
            .AsEnumerable().ToList();

Answer 4

Linq providers usually understands basic methods on arrays/collections. Therefore you can use Contains method.

var zones = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri)
     .Where(z => z.Type == typeof(ZoneDO).ToString() && 
     user.UserPreference.Zones.Contains(z.Id))
     .AsEnumerable().ToList();

Answer 5

So apparently you have a user . This user has a UserPreference and this UserPreference has zero or more Zones . It seems that this user , and the Zones of this user's UserPreference is in local memory (not in a database. The Zones are IEnumerable and not IQueryable)

Although you didn't specify, it seems that DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri) returns an IQueryable<ZoneDO>

You want all ZoneDo that have an Id that is an Id of one of the Zones in the one and only UserPreference of your user.

In baby steps:

IEnumerable<Guid> zoneIds = user.Userpreference.Zones.Select(zone => zone.Id);
IQueryable<ZoneDO> allZoneDOs = DbUtil.Client.CreateDocumentQuery<ZoneDO>(CollectionUri);

IEnumerable<ZoneDO> requestedZoneDOs = allZoneDOs
    .Where(zoneDo => zoneIds.Contains(zoneDo.Id);

Until now no query is performed, nor any enumeration. To perform the query and return the fetched data as a List<ZoneDO> use .ToList() ;

List<ZoneDO> documents = requestedZoneDOs.ToList();

TODO: if desired put all statements into one big LINQ statement. I doubt whether this will improve performance. It surely will deteriorate readability and thus maintainability.

Did you notice that I did not do your type checking part. This was not needed, because function CreateDocumentQuery<ZoneDO> already returns a sequence f ZoneDo .

If not, and there are other types in the returned sequence, use OfType<ZoneDo> instead of checking on string representation of the returned objects:

IQueryable<ZoneDO> allZoneDOs = DbUtil.Client
    .CreateDocumentQuery<ZoneDO>(CollectionUri)
    .OfType<ZoneDo>();

AsEnumerable is not needed. IQueryable.ToList() will perform the query and convert the data to a list.

AsEnumerable is only needed if you need the data in local memory to continue with LINQ statements that cannot be performed as IQueryable, like LINQ statements where you call local functions, or LINQ statements that cannot be translated into SQL.

AsEnumerable will fetch the requested data per 'page'. So if you only need the first (few) elements, you don't fetch the complete table, but only the first (few) pages.