Enable the slow query log by setting slow_query_log = ON and configure long_query_time in MySQL’s config file or dynamically. 2. Analyze logged queries using tools like mysqldumpslow or pt-query-digest to identify slow or frequent queries. 3. Use SHOW FULL PROCESSLIST and Performance Schema to monitor real-time query performance. 4. Optimize identified queries by adding indexes, avoiding full table scans, and rewriting inefficient SQL. 5. Regularly monitor and tune as data and usage evolve to maintain performance.
To find slow queries in MySQL, the most effective approach is to enable and analyze the slow query log. This feature logs all queries that take longer than a specified time to execute, helping you identify performance bottlenecks.
Enable the Slow Query Log
Make sure the slow query log is turned on. You can check its status:
SHOW VARIABLES LIKE 'slow_query_log';If it's off, enable it by adding these lines to your MySQL configuration file (my.cnf or my.ini):
- slow_query_log = ON
- slow_query_log_file = /path/to/your/slow.log
- long_query_time = 1 (logs queries taking more than 1 second)
- log_queries_not_using_indexes = ON (optional: logs queries that don't use indexes)
Restart MySQL or set these dynamically (if supported):
SET GLOBAL slow_query_log = 'ON';SET GLOBAL long_query_time = 1;
SET GLOBAL log_queries_not_using_indexes = 'ON';
Analyze the Slow Query Log
Once logging is active, let your application run under normal load. Then use tools to analyze the log:
-
mysqldumpslow: A built-in tool to summarize slow log entries.
Example: mysqldumpslow /path/to/slow.log -
pt-query-digest (from Percona Toolkit): A more advanced tool that provides detailed analysis.
Example: pt-query-digest /path/to/slow.log
These tools show the most frequent or longest-running queries, helping prioritize optimization efforts.
Use Performance Schema and SHOW PROCESSLIST
For real-time insight into currently running slow queries:
- Run SHOW FULL PROCESSLIST; to see active queries. Look for those with high "Time" values.
- Query the Performance Schema for detailed execution stats:
SELECT * FROM performance_schema.events_statements_summary_by_digest
ORDER BY SUM_TIMER_WAIT DESC LIMIT 10;
This shows the slowest queries by average or total execution time, based on normalized SQL statements.
Monitor and Optimize Regularly
Slow queries often emerge as data grows or usage patterns change. Set up regular monitoring using the slow log and tools like pt-query-digest. Focus on:
- Queries with high execution time or frequency
- Queries doing full table scans
- Missing index suggestions from the log
Add proper indexes, rewrite inefficient SQL, and test changes under load.
Basically, turn on the slow query log, use analysis tools, and act on the findings. It’s simple but powerful for ongoing database performance tuning.
The above is the detailed content of How to find slow queries in MySQL. 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.

ArtGPT
AI image generator for creative art from text prompts.

Stock Market GPT
AI powered investment research for smarter decisions

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)

The answer is: MySQL's CASE statement is used to implement conditional logic in query, and supports two forms: simple and search. Different values ??can be dynamically returned in clauses such as SELECT, WHERE, and ORDERBY; for example, in SELECT, classification of scores by fractional segments, combining aggregate functions to count the number of states, or prioritizing specific roles in ORDERBY, it is necessary to always end with END and it is recommended to use ELSE to handle the default situation.

Create a shell script containing the database configuration and mysqldump command and save it as mysql_backup.sh; 2. Store MySQL credentials by creating ~/.my.cnf file and set 600 permissions to improve security, modify the script to use configuration file authentication; 3. Use chmod x to make the script executable and manually test whether the backup is successful; 4. Add timed tasks through crontab-e, such as 02/path/to/mysql_backup.sh>>/path/to/backup/backup.log2>&1, realize automatic backup and logging at 2 a.m. every day; 5.

INSERT...ONDUPLICATEKEYUPDATE implementation will be updated if it exists, otherwise it will be inserted, and it requires unique or primary key constraints; 2. Reinsert after deletion of REPLACEINTO, which may cause changes in the auto-increment ID; 3. INSERTIGNORE only inserts and does not repetitive data, and does not update. It is recommended to use the first implementation of upsert.

Use the DISTINCT keyword to remove duplicate values ??from the specified column and return unique values. 1. The basic syntax is SELECTDISTINCTcolumn_nameFROMtable_name; 2. Query the unique value of a single column, such as SELECTDISTINCTcityFROMcustomers; 3. Query the unique combination of multiple columns, such as SELECTDISTINCTcity, stateFROMcustomers; 4. Filter with the WHERE clause and get the unique value, such as SELECTDISTINCTproduct_nameFROMordersWHEREorder_date>'202

EXPLAINinMySQLrevealsqueryexecutionplans,showingindexusage,tablereadorder,androwfilteringtooptimizeperformance;useitbeforeSELECTtoanalyzesteps,checkkeycolumnsliketypeandrows,identifyinefficienciesinExtra,andcombinewithindexingstrategiesforfasterqueri

Subqueries can be used in WHERE, FROM, SELECT, and HAVING clauses to implement filtering or calculation based on the result of another query. Operators such as IN, ANY, ALL are commonly used in WHERE; alias are required as derivative tables in FROM; single values ??must be returned in SELECT; related subqueries rely on outer query to execute each row. For example, check employees whose average salary is higher than the department, or add the company average salary list. Subqueries improve logical clarity, but performance may be lower than JOIN, so you need to ensure that you return the expected results.

Use UTC to store time, set the MySQL server time zone to UTC, use TIMESTAMP to realize automatic time zone conversion, adjust the time zone according to user needs in the session, display the local time through the CONVERT_TZ function, and ensure that the time zone table is loaded.

MySQL can calculate geographical distances through the Haversine formula or the ST_Distance_Sphere function. The former is suitable for all versions, and the latter provides easier and more accurate spherical distance calculations since 5.7.
