• author: PlanetScale

Counting in MySQL: Dispelling the Myth of Count Star

Counting rows in a MySQL database is a fundamental operation that developers frequently perform. However, there exists a persistent myth surrounding the use of count(*), often referred to as count star. Many developers claim that count star is slow and should be avoided in favor of alternatives like count ID.

In this article, we will delve into the reasons behind this myth and explore why the claim is incorrect. Additionally, we will provide evidence to support the fact that count star is, in fact, the fastest way to count rows in MySQL.

The Myth: Count Star is Slow

The myth surrounding count star suggests that using this syntax to count rows in a MySQL database is inefficient and should be avoided. According to the myth, utilizing count(*) results in a slow execution because it requires scanning all the columns of a table, which consumes a significant amount of time and resources.

Count Star: Optimized for Speed

Contrary to the myth, count star is specifically optimized to be the fastest method for counting rows in MySQL. This optimization makes the count(*) syntax efficient and reliable, even for large databases with numerous columns.

To understand why count star is optimized for speed, it is essential to grasp its intended functionality. The star symbol (*) in count(*) does not represent all columns but rather serves as a placeholder for anything that can be counted. By utilizing count(*), developers essentially delegate control to MySQL, requesting it to count the rows using the quickest method possible.

The Primary Index vs. Secondary Index

To comprehend why count star is the preferred method for counting rows, it's important to understand the structure of MySQL indexes. In MySQL, tables have a primary key, which acts as the clustered index determining the physical arrangement of rows on disk. Apart from the primary index, tables can also have secondary indexes.

Unlike primary indexes, secondary indexes solely store specific fields (e.g., due date or created at) and are highly compact on disk. Consequently, counting rows using a secondary index is incredibly fast when compared to traversing the entirety of a primary index.

Demystifying the Myth with Practical Examples

Now, let's explore some practical examples to dispel the myth surrounding count star.

Consider the following query:


Assuming we have a table named to_do, we can analyze the execution plan using the EXPLAIN statement. Surprisingly, even if we don't mention the due date column (or even its existence), MySQL intelligently uses the secondary index on the due date to optimize the count(*) operation.

This intelligent behavior stems from the underlying MySQL optimizer, which recognizes the logical intent of the query and seeks the most efficient method to achieve the desired result. In this case, MySQL understands that the goal is to count the rows, allowing it to leverage the compact secondary index on the due date column to swiftly count the relevant entries.

To further illustrate this, let's examine the structure of the to_do table:


The output will reveal the table structure, including the primary key, secondary indexes, and additional details.

Count Star vs. Count of Specific Columns

To emphasize the superiority of count star, let's compare it with alternative methods like count ID or count of a specific constant.


Surprisingly, neither of these queries uses the ID column directly. The MySQL optimizer recognizes that counting the secondary index (i.e., the due date index) is a more efficient approach, resulting in equivalent results with significantly faster execution.

By default, MySQL protects developers from inefficient practices by dynamically adjusting the execution plan. It leverages the knowledge of the database schema and statistics to determine the most appropriate index for counting rows.

Debunking the Myth: Count Star is Efficient

To dispel the myth once and for all, it's crucial to reiterate that count star is not slow but, instead, incredibly efficient in counting rows in MySQL. The optimization behind this syntax, which delegates the counting process to MySQL, ensures that the quickest method available is utilized.

Instead of navigating through the primary index, MySQL smartly takes advantage of secondary indexes, which are compact and store only the necessary data for counting rows. This optimization results in significantly faster execution times, improving the performance of counting operations.

Spread the Word at Thanksgiving Gatherings

Next time you find yourself embroiled in a discussion about the efficiency of count(*) versus count ID, armed with this knowledge, you can confidently assert that count star is the recommended and fastest way to count rows in MySQL. By providing the correct information, you can settle the debate and enjoy a victorious Thanksgiving gathering where you emerge as the winner of the argument.

For more insightful content and resources related to MySQL, make sure to visit the official PlanetScale website at planetscale.com/mysql or subscribe to their YouTube channel.

In summary, the myth surrounding the sluggishness of count(*) in MySQL is nothing more than a misconception. The optimization present in this syntax proves that it is the most efficient way to count rows in a given table. By embracing count star, developers can streamline their code and improve the overall performance of their applications.

Previous Post


Next Post

How to Create and Use a Service in Angular

About The auther

New Posts

Popular Post