为什么此Entity Framework LINQ查询生成一个缓慢的where子句？

Question

I was asked to investigate the cause of a poorly performing query in our database. I determined it was generated by a LINQ statement and tracked it to the source code and loaded that into linqpad. In Linqpad I displayed the generated SQL, shown below. As you can see, the first part of the WHERE clause is unnecessary and greatly slows down the query by avoiding indexes. It should just be querying on the DocumentStorageId key and that's it. There is no point to the IN() statement, every row in the product table has one of those values, and is not null. Any ideas on how I can change my linq statement so the ID is first and hit by indexes?

void Main()
{
    var uow = new UnitOfWork(this);
    var repo = new Repository<Product>(this,uow);   
    var documentStorageId = new Guid("473BAE6B-A1A1-49BE-9FD5-AB6B870A82B1");
    var result = repo.Queryable()
                .Where(x => x.DocumentStorageId == documentStorageId)                
                .FirstOrDefault();
    result.Dump();              
}

Generated SQL Output:

    SELECT    
        [Extent1].[AColumn],
        [Extent1].[BColumn]
    FROM [dbo].[Product] AS [Extent1]
    WHERE
          ([Extent1].[ProductType] IN      
                (N'Type1',N'Type2',N'Type3',N'Type4',N'Type5',N'Type6')) 
     AND ([Extent1].[DocumentStorageId] = @p__linq__0)

EDIT: TO clarify further, the model is created using Code First. Product is a base class. There are 6 derived types of product (Type1, Type2, etc). ProductType is the discriminator column. So it seems like EF is trying to include every possible type of Product, but why bother? Including all is the same as not specifying a particular one, and the IN() clause makes the query perform slowly.

Answer 1

With TPH typed queries like the one you are doing EF needs to work out which types you are interested in. It does not know it has a complete list of types, only that when you request the root type in your application the list of derived types is as follows. That means that EF must include the list of types to avoid issues.

There are two ways to resolve this.

1. Bind a non-tph DbSet in your context and use that.
2. Add an index on (ProductType, DocumentStorageId) so that the in here can be fast

Answer 2

There are 6 derived types of product (Type1, Type2, etc). ProductType is the discriminator column.

You know this... but there is no way for EF to know this. For all it knows, you have 20 product types in there, but only told EF about those 6. Imagine the confusion when you asked for all of them, and it brought back 20, even though there are only 6 you programmed for.

Why is this Entity Framework LINQ query generating a slow where clause?

Therefore, in order for a query to return as expected, the in clause is used here. (Also one of the reasons I prefer TPT over TPH).