Entity Framework Core count does not have optimal performance

Question

I need to get the amount of records with a certain filter.

Theoretically this instruction:

_dbContext.People.Count (w => w.Type == 1);

It should generate SQL like:

Select count (*)
from People
Where Type = 1

However, the generated SQL is:

Select Id, Name, Type, DateCreated, DateLastUpdate, Address
from People
Where Type = 1

The query being generated takes much longer to run in a database with many records.

I need to generate the first query.

If I just do this:

_dbContext.People.Count ();

Entity Framework generates the following query:

Select count (*)
from People

.. which runs very fast.

How to generate this second query passing search criteria to the count?

Answer 1

There is not much to answer here. If your ORM tool does not produce the expected SQL query from a simple LINQ query, there is no way you can let it do that by rewriting the query (and you shouldn't be doing that at the first place).

EF Core has a concept of mixed client/database evaluation in LINQ queries which allows them to release EF Core versions with incomplete/very inefficient query processing like in your case.

Excerpt from Features not in EF Core (note the word not) and Roadmap:

Improved translation to enable more queries to successfully execute, with more logic being evaluated in the database (rather than in-memory).

Shortly, they are planning to improve the query processing, but we don't know when will that happen and what level of degree (remember the mixed mode allows them to consider query "working").

So what are the options?

• First, stay away from EF Core until it becomes really useful. Go back to EF6, it's has no such issues.
• If you can't use EF6, then stay updated with the latest EF Core version.

For instance, in both v1.0.1 and v1.1.0 you query generates the intended SQL (tested), so you can simply upgrade and the concrete issue will be gone.

But note that along with improvements the new releases introduce bugs/regressions (as you can see here EFCore returning too many columns for a simple LEFT OUTER join for instance), so do that on your own risk (and consider the first option again, i.e. Which One Is Right for You :)

Answer 2

Try to use this lambda expression for execute query faster.

_dbContext.People.select(x=> x.id).Count();

Answer 3

Try this

(from x in _dbContext.People where x.Type == 1 select x).Count();

or you could do the async version of it like:

await (from x in _dbContext.People where x.Type == 1 select x).CountAsync();

and if those don't work out for you, then you could at least make the query more efficient by doing:

(from x in _dbContext.People where x.Type == 1 select x.Id).Count();

or

await (from x in _dbContext.People where x.Type == 1 select x.Id).CountAsync();

Answer 4

If you want to optimize performance and the current EF provider is not not (yet) capable of producing the desired query, you can always rely on raw SQL.

Obviously, this is a trade-off as you are using EF to avoid writing SQL directly, but using raw SQL can be useful if the query you want to perform can't be expressed using LINQ, or if using a LINQ query is resulting in inefficient SQL being sent to the database.

A sample raw SQL query would look like this:

var results = _context.People.FromSql("SELECT Id, Name, Type, " +
                                      "FROM People " +
                                      "WHERE Type = @p0",                                                     
                                      1);

As far as I know, raw SQL queries passed to the FromSql extension method currently require that you return a model type, i.e. returning a scalar result may not yet be supported.

You can however always go back to plain ADO.NET queries:

using (var connection = _context.Database.GetDbConnection())
{
    connection.Open();

    using (var command = connection.CreateCommand())
    {
        command.CommandText = "SELECT COUNT(*) FROM People WHERE Type = 1";
        var result = command.ExecuteScalar().ToString();
    }
}

Answer 5

It seems that there has been some problem with one of the early releases of Entity Framework Core. Unfortunately you have not specified exact version so I am not able to dig into EF source code to tell what exactly has gone wrong.

To test this scenario, I have installed the latest EF Core package and managed to get correct result.

Here is my test program:

And here is SQL what gets generated captured by SQL Server Profiler:

As you can see it matches all the expectations.

Here is the excerpt from packages.config file:

...
<package id="Microsoft.EntityFrameworkCore" version="1.1.0" targetFramework="net452" />
...

So, in your situation the only solution is to update to the latest package which is 1.1.0 at the time of writing this.

Answer 6

Does this get what you want:

_dbContext.People.Where(w => w.Type == 1).Count();

Answer 7

I am using EFCore 1.1 here.

This can occur if EFCore cannot translate the entire Where clause to SQL. This can be something as simple as DateTime.Now that might not even think about.

The following statement results in a SQL query that will surprisingly run a SELECT * and then C# .Count() once it has loaded the entire table!

   int sentCount = ctx.ScheduledEmail.Where(x => x.template == template &&
                   x.SendConfirmedDate > DateTime.Now.AddDays(-7)).Count();

But this query will run an SQL SELECT COUNT(*) as you would expect / hope for:

   DateTime earliestDate = DateTime.Now.AddDays(-7);
   int sentCount = ctx.ScheduledEmail.Where(x => x.template == template 
                   && x.SendConfirmedDate > earliestDate).Count();

Crazy but true. Fortunately this also works:

   DateTime now = DateTime.Now;
   int sentCount = ctx.ScheduledEmail.Where(x => x.template == template &&
                   x.SendConfirmedDate > now.AddDays(-7)).Count();

Answer 8

sorry for the bump, but...

probably the reason the query with the where clause is slow is because you didnt provide your database a fast way to execute it.

in case of the select count(*) from People query we dont need to know the actual data for each field and we can just use a small index that doesnt have all these fields in them so we havent got to spend our slow I/O on. The database software would be clever enough to see that the primary key index requires the least I/O to do the count on. The pk id's require less space than the full row so you get more back to count per I/O block so you can complete faster.

Now in the case of the query with the Type it needs to read the Type to determine it's value. You should create an index on Type if you want your query to be fast or else it will have to do a very slow full table scan, reading all rows. It helps when your values are more discriminating. A column Gender (usually) only has two values and isnt very discriminating, a primary key column where every value is unique is highly dscriminating. Higher discriminating values will result in a shorter index range scan and a faster result to the count.

Answer 9

What I used to count rows using a search query was

_dbContext.People.Where(w => w.Type == 1).Count();

This can also be achieved by

List<People> people = new List<People>();
people = _dbContext.People.Where(w => w.Type == 1);
int count = people.Count();

This way you will get the people list too if you need it further.