Question

Here a sample dataset:

OrderProduct is a table that contains the productIds that were part of a given order.
Note: OrderProduct is a database table and I am using EF.

OrderId, ProductId

1, 1

2, 2

3, 4

3, 5

4, 5

4, 2

5, 2

5, 3

What I want to be able to do is find an order that contains only the productIds that I am searching for. So if my input was productIds 2,3, then I should get back OrderId 5.

I know how I can group data, but I am unsure of how to perform the select on the group.

Here is what I have:

var q = from op in OrderProduct
group op by op.OrderId into orderGroup
select orderGroup;

Not sure how to proceed from here

Answer 1

IEnumerable<int> products = new List<int> {2, 3};

IEnumerable<OrderProduct> orderProducts = new List<OrderProduct>
{
   new OrderProduct(1, 1), 
   new OrderProduct(2, 2), 
   new OrderProduct(3, 4), 
   new OrderProduct(3, 5), 
   new OrderProduct(4, 5), 
   new OrderProduct(4, 2), 
   new OrderProduct(5, 2), 
   new OrderProduct(5, 3),
};

var orders =
   (from op in orderProducts
    group op by op.OrderId into orderGroup
    //magic goes there
    where !products.Except(orderGroup.Select(x => x.ProductId)).Any()
    select orderGroup);

//outputs 5
orders.Select(x => x.Key).ToList().ForEach(Console.WriteLine);

Or you can have another version as pointed in another answer, just replace

 where !products.Except(orderGroup.Select(x => x.ProductId)).Any()

on

 where products.All(pid => orderGroup.Any(op => op.ProductId == pid))

second one will have ~ 15% better performance (I’ve checked that)

Edit

According to the last requirement change, that you need orders that contain not all productIds you are searching, but exactly those and only those productIds, I wrote an updated version:

 var orders =
       (from op in orderProducts
        group op by op.OrderId into orderGroup
        //this line was added
        where orderGroup.Count() == products.Count()
        where !products.Except(orderGroup.Select(x => x.ProductId)).Any()
        select orderGroup);

So the only thing you’ll need is to add a precondition ensuring that collections contains the same amount of elements, it will work for both previous queries, and as a bonus I suggest 3rd version of the most important where condition:

where orderGroup.Select(x => x.ProductId).Intersect(products).Count() == orderGroup.Count()