Understanding the MySQL EXPLAIN statement for query analysis
Jul 06, 2025 am 02:51 AMTo troubleshoot the reasons why MySQL query is slow, it is key to use the EXPLAIN statement to analyze the execution plan. 1. First, check the type column, and the priority should be system, const, eq_ref and other efficient connection types. If ALL appears, it needs to be optimized, such as adding indexes or refactoring queries; 2. Secondly, focus on the Extra column. If "Using filesort" or "Using temporary" appears, it means that there is additional overhead, and it may be necessary to index the sorting or grouping fields; 3. Check the rows column to evaluate the number of scan rows. Too high values ??may lead to increased I/O and time. Scans can be reduced by optimizing indexes or adjusting the JOIN order; 4. Finally, in MySQL 8.0, EXPLAIN ANALYZE can be used to obtain actual execution details to help more accurately identify performance bottlenecks. Mastering these steps can help quickly locate and optimize slow query problems.
When you're trying to figure out why a MySQL query is slow, the EXPLAIN
statement is one of your best tools. It shows how MySQL plans to execute a query and helps identify potential bottlenecks—like missing indexes or inefficient joins—before they become real problems.

Here are some key things to look for when using EXPLAIN
.

1. Check the type
column – it tells you about the join type
The type
column in the output gives you an idea of ??how efficient a table access is.
You want this to be as high up the efficiency ladder as possible.
Common values ??(from best to worse):

-
system
orconst
: Very fast, usually when querying by a primary key. -
eq_ref
: Good for joins on unique keys. -
ref
: OK, used when matching non-unique keys. -
range
: Still acceptable, used withIN
,BETWEEN
, or indexed conditions. -
index
: Full index scan, not great but better than scanning all rows. -
ALL
: Full table scan, often a red flag.
If you see ALL
here, especially on large tables, that's a good place to start optimizing—maybe add an index or rethink the query structure.
2. Look at the Extra
column – it reveals hidden costs
This column often contains important hints like whether filesors or temporary tables are being used.
Watch for:
-
"Using filesort"
: MySQL needs to do an extra sort pass, which can be slow. -
"Using temporary"
: A temporary table is created, often due to complex grouping or joins. -
"Using where"
: Indicates filtering is happening after reading rows. -
"Impossible WHERE"
: Might suggest a typo or logic error in the query.
For example, if you're ordering by a non-indexed column and filtering with a WHERE
, you might see both "Using filesort"
and "Using where"
. That combination is a hint that adding an index could help.
3. Pay attention to rows
– it estimates the workload
MySQL's optimizer gives an estimate of how many rows it thinks it will need to exam. This number isn't always 100% accurate, but it gives you a ballpark idea of ??performance impact.
A high number in the rows
column means:
- More disk I/O
- Longer execution time
- Potential for memory pressure
If you see tens of thousands or more, especially early in the query plan, consider whether you can reduce that number by:
- Adding better indexes
- Filtering earlier
- Restructuring joins
Also note that sometimes the rows
count looks low, but the query is still slow. In those cases, double-check the Extra
column—it might explain why the actual work is heavier than expected.
4. Use EXPLAIN with different SQL modes (like ANALYZE)
In newer versions of MySQL (8.0 ), you can use EXPLAIN ANALYZE
, which runs the query and shows actual execution details. This gives you more accurate insight into what really happens—not just what the optimizer thinks will happen.
It shows:
- How long each step actually took
- How many rows were read
- Whether buffers helped or hurt
This is especially useful when the estimated rows
from regular EXPLAIN
doesn't match reality.
Understanding EXPLAIN
takes a bit of practice, but once you get the hang of reading the output, it becomes second nature. You'll start spotting issues quickly and making smarter decisions about indexing and query design.
Basically that's it.
The above is the detailed content of Understanding the MySQL EXPLAIN statement for query analysis. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

mysqldump is a common tool for performing logical backups of MySQL databases. It generates SQL files containing CREATE and INSERT statements to rebuild the database. 1. It does not back up the original file, but converts the database structure and content into portable SQL commands; 2. It is suitable for small databases or selective recovery, and is not suitable for fast recovery of TB-level data; 3. Common options include --single-transaction, --databases, --all-databases, --routines, etc.; 4. Use mysql command to import during recovery, and can turn off foreign key checks to improve speed; 5. It is recommended to test backup regularly, use compression, and automatic adjustment.

When handling NULL values ??in MySQL, please note: 1. When designing the table, the key fields are set to NOTNULL, and optional fields are allowed NULL; 2. ISNULL or ISNOTNULL must be used with = or !=; 3. IFNULL or COALESCE functions can be used to replace the display default values; 4. Be cautious when using NULL values ??directly when inserting or updating, and pay attention to the data source and ORM framework processing methods. NULL represents an unknown value and does not equal any value, including itself. Therefore, be careful when querying, counting, and connecting tables to avoid missing data or logical errors. Rational use of functions and constraints can effectively reduce interference caused by NULL.

GROUPBY is used to group data by field and perform aggregation operations, and HAVING is used to filter the results after grouping. For example, using GROUPBYcustomer_id can calculate the total consumption amount of each customer; using HAVING can filter out customers with a total consumption of more than 1,000. The non-aggregated fields after SELECT must appear in GROUPBY, and HAVING can be conditionally filtered using an alias or original expressions. Common techniques include counting the number of each group, grouping multiple fields, and filtering with multiple conditions.

MySQL paging is commonly implemented using LIMIT and OFFSET, but its performance is poor under large data volume. 1. LIMIT controls the number of each page, OFFSET controls the starting position, and the syntax is LIMITNOFFSETM; 2. Performance problems are caused by excessive records and discarding OFFSET scans, resulting in low efficiency; 3. Optimization suggestions include using cursor paging, index acceleration, and lazy loading; 4. Cursor paging locates the starting point of the next page through the unique value of the last record of the previous page, avoiding OFFSET, which is suitable for "next page" operation, and is not suitable for random jumps.

To view the size of the MySQL database and table, you can query the information_schema directly or use the command line tool. 1. Check the entire database size: Execute the SQL statement SELECTtable_schemaAS'Database',SUM(data_length index_length)/1024/1024AS'Size(MB)'FROMinformation_schema.tablesGROUPBYtable_schema; you can get the total size of all databases, or add WHERE conditions to limit the specific database; 2. Check the single table size: use SELECTta

To set up asynchronous master-slave replication for MySQL, follow these steps: 1. Prepare the master server, enable binary logs and set a unique server-id, create a replication user and record the current log location; 2. Use mysqldump to back up the master library data and import it to the slave server; 3. Configure the server-id and relay-log of the slave server, use the CHANGEMASTER command to connect to the master library and start the replication thread; 4. Check for common problems, such as network, permissions, data consistency and self-increase conflicts, and monitor replication delays. Follow the steps above to ensure that the configuration is completed correctly.

MySQL supports transaction processing, and uses the InnoDB storage engine to ensure data consistency and integrity. 1. Transactions are a set of SQL operations, either all succeed or all fail to roll back; 2. ACID attributes include atomicity, consistency, isolation and persistence; 3. The statements that manually control transactions are STARTTRANSACTION, COMMIT and ROLLBACK; 4. The four isolation levels include read not committed, read submitted, repeatable read and serialization; 5. Use transactions correctly to avoid long-term operation, turn off automatic commits, and reasonably handle locks and exceptions. Through these mechanisms, MySQL can achieve high reliability and concurrent control.

Character set and sorting rules issues are common when cross-platform migration or multi-person development, resulting in garbled code or inconsistent query. There are three core solutions: First, check and unify the character set of database, table, and fields to utf8mb4, view through SHOWCREATEDATABASE/TABLE, and modify it with ALTER statement; second, specify the utf8mb4 character set when the client connects, and set it in connection parameters or execute SETNAMES; third, select the sorting rules reasonably, and recommend using utf8mb4_unicode_ci to ensure the accuracy of comparison and sorting, and specify or modify it through ALTER when building the library and table.
