This article walks through a real‑world MySQL slow‑query case, showing how to identify the bottleneck with EXPLAIN, design covering and composite indexes, rewrite the SQL, tune InnoDB parameters, and safely deploy the changes, ultimately shrinking execution time from seconds to a few milliseconds.
This article examines ten typical situations where MySQL indexes become ineffective, explains the underlying reasons such as function usage, implicit type conversion, wildcard LIKE patterns, OR conditions, left‑most prefix violations, small tables, stale statistics, NULL handling, GROUP BY/DISTINCT, and ORDER BY, and provides concrete SQL examples and step‑by‑step remediation techniques to restore optimal query performance.
This guide walks through a systematic approach to identify, analyze, and fix MySQL slow queries by enabling the slow‑query log, interpreting its format, using tools like mysqldumpslow and pt‑query‑digest, examining execution plans with EXPLAIN, designing proper indexes, rewriting SQL, tuning server parameters, and establishing continuous monitoring to prevent regressions.
This guide explains the six common reasons why MySQL indexes may fail to improve query speed, shows how interviewers evaluate index knowledge, and provides concrete SQL examples, EXPLAIN analysis, and practical optimization techniques such as redesigning indexes, using covering indexes, avoiding implicit type conversion, and tuning database configuration.
This comprehensive guide explains how to detect, analyze, and optimize MySQL slow queries by configuring the slow‑query log, using pt‑query‑digest, interpreting EXPLAIN output, designing effective B+Tree indexes, avoiding common index pitfalls, optimizing count(*) operations, improving deep pagination, rewriting inefficient SQL patterns, and applying advanced table design techniques such as partitioning and sharding.
This article provides a hands‑on guide to MySQL index optimization, deeply exploring EXPLAIN execution plans, new features in MySQL 8/8.4, practical index design principles, step‑by‑step SQL examples, common pitfalls, advanced techniques like functional and descending indexes, and comprehensive monitoring and troubleshooting strategies.
Adding a LIMIT 1 clause to a MySQL query that fetches the latest order for a user can unexpectedly trigger a full‑table scan, slowing execution by up to 50 times; this article explains the optimizer’s mis‑choice, shows EXPLAIN analysis, and offers three practical remedies.
This article walks through a real‑world MySQL slow‑query case, explains the inner workings of Join and Order by algorithms, shows how to interpret EXPLAIN and Optimizer_trace output, and demonstrates how adding an index can transform a costly Block Nested‑Loop Join into a fast Index Nested‑Loop Join, dramatically improving performance.
This article explains MySQL’s Optimizer Trace feature, covering its purpose, required system variables, how to enable it, the structure of its JSON output, and how to interpret the preparation, optimization, and execution stages to diagnose query‑plan decisions.
This guide introduces MySQL's EXPLAIN command, demonstrates how to create sample order and customer tables, runs various queries, and provides a detailed walkthrough of each column in the execution plan—including id, select_type, table, type, possible_keys, key, key_len, ref, rows, filtered, and extra—plus indexing tips and visual examples.
This article explains the purpose of MySQL’s optimizer_switch ‘prefer_ordering_index’, shows how it affects ORDER BY/GROUP BY queries with LIMIT, provides sample tables and procedures, compares EXPLAIN output with the option ON and OFF, and concludes why disabling it is often the safer choice for most workloads.
This guide walks you through the fundamentals of MySQL performance tuning—covering the optimization pyramid, how to read EXPLAIN plans, practical index design, safe online DDL for large tables, and interview‑ready case studies that turn SQL expertise into a powerful hiring advantage.
This guide explains how to enable MySQL slow‑query logging, set appropriate thresholds, locate problematic SQL statements, analyze execution plans with EXPLAIN, and apply index or query rewrites to dramatically improve performance.
This guide walks through enabling MySQL slow query logging, analyzing logs with pt‑query‑digest, interpreting EXPLAIN output, applying index and SQL optimizations, tuning database parameters, and setting up Prometheus monitoring, culminating in a real‑world order‑query case that reduces execution time from seconds to milliseconds.
This article explains the concepts of driving and driven tables in MySQL JOIN queries, shows how the optimizer chooses their order based on data size, indexes and filters, provides concrete examples with EXPLAIN output, and offers practical tips to control and improve table selection for better performance.
This article explains how to verify whether MySQL uses an index with EXPLAIN, outlines eight common reasons why an index may be ignored—including better alternatives, low selectivity, stale statistics, full‑table scans, structural limitations, function usage, invisible indexes—and provides practical commands and hints to resolve each issue.
This article explains the core purpose of MySQL indexes, enumerates twelve typical situations that cause index failure, provides concrete SQL examples and corrections, and shows how to use EXPLAIN to diagnose and verify index usage for better query performance.
Learn how to leverage MySQL's EXPLAIN and EXPLAIN ANALYZE commands to diagnose query performance, understand each column of the output, choose appropriate indexes, and apply practical optimization steps—including multi‑column indexes—to dramatically reduce row scans and speed up queries.
This article walks through a real-world slow‑SQL case, explains the inner workings of Join and Order‑by algorithms, demonstrates using EXPLAIN and optimizer_trace to trace execution, and shows how adding indexes and choosing the right join method can dramatically improve MySQL query performance.
This article explains how MySQL's EXPLAIN and EXPLAIN ANALYZE statements work, compares their outputs, and demonstrates through three practical examples how to interpret actual execution costs, row counts, and loop information to identify indexing and query‑plan inefficiencies.
This guide walks you through identifying MySQL bottlenecks, using EXPLAIN, optimizing indexes, rewriting queries, tuning configuration, applying architectural patterns, and learning from real‑world cases to dramatically speed up your database.
This article explains how to use MySQL's EXPLAIN command to analyze slow queries, interprets each field in the execution plan, provides practical examples and optimization techniques, and offers advanced diagnostics for improving index usage and overall SQL performance.
This article walks you through diagnosing slow MySQL queries using EXPLAIN, fixing index issues, reordering joins, forcing optimal indexes, monitoring index usage, and applying systematic governance such as SQL sanitization and sharding to dramatically improve performance.
This article walks through a mini‑project that creates a student table, adds indexes, populates it with 100 k rows, and then demonstrates six concrete scenarios—such as leading wildcards, arithmetic on indexed columns, functions, type mismatches, composite‑index misuse, and encoding differences—that cause MySQL indexes to become ineffective, showing the EXPLAIN output for each case.
This article examines whether adding an index to a status field in a multi‑million‑row MySQL table improves query performance, covering the index lookup process, extreme cases, selectivity, result‑set size impact, composite indexes, partitioning, and how to verify plans with EXPLAIN.
This article explains why SQL statements become performance bottlenecks as data grows, outlines a systematic optimization workflow—including slow‑query identification, EXPLAIN analysis, profiling, and tracing—and discusses practical solutions for index usage, query rewriting, pagination, range queries, and large‑scale data handling in MySQL.
This article explains the three MySQL EXPLAIN output formats—TRADITIONAL, JSON, and TREE—demonstrates how the JSON format provides richer cost and data‑read information, compares query costs of sample SQL statements, and offers practical optimization suggestions for poorly performing joins.
This article explains what the rows column in MySQL EXPLAIN means, demonstrates three situations—when a small rows value indicates good performance, when it does not, and when rows is misleading—using concrete SQL examples, force‑index tricks, and multi‑table join analyses to show why rows alone cannot reliably judge query efficiency.
This article explains the most frequent MySQL EXPLAIN EXTRA hints—Using filesort, Using temporary, and Using join buffer—detailing when they appear, how to interpret them, and practical optimization strategies illustrated with concrete SQL examples and execution‑plan outputs.
This article explains how to read MySQL's EXPLAIN EXTRA column, covering SEMI JOIN hints such as FirstMatch, Start/End temporary, LooseScan, and the Range‑checked‑for‑each‑record optimization, with concrete examples and command‑line output to illustrate each case.
This guide walks through identifying slow MySQL queries using EXPLAIN, explains each output field, and presents practical optimization techniques—including proper index usage, pagination tricks, join improvements, and ORDER/GROUP BY tuning—to dramatically boost query performance.
This article experimentally compares the performance of various MySQL COUNT queries on an InnoDB table with one million rows, explains the underlying execution plans using EXPLAIN, analyzes primary‑key versus secondary‑index behavior, and contrasts InnoDB’s fast count implementation.
This article explains how to analyze MySQL slow queries by examining response time, scanned rows, and returned rows, demonstrates EXPLAIN output with and without indexes, and covers index types, column ordering, left‑most prefix rules, and sorting strategies to improve database performance.
This article explains the meaning and optimization strategies for various MySQL EXPLAIN EXTRA hints—including Impossible WHERE/HAVING, No matching rows, Recursive queries, Rematerialize, and canned N databases—provides example execution plans, code snippets, and performance comparisons to help developers write more efficient SQL statements.
This article explains the meaning of the Extra column in MySQL EXPLAIN results, covering common values such as Using index, Backward index scan, Select tables optimized away, and Zero limit, and shows how to interpret and optimize each case with concrete examples.
This article explains MySQL EXPLAIN type column, detailing the inefficiencies of type=ALL, how adding ORDER BY can change it to index, and demonstrates the use of INDEX_MERGE for UNION and INTERSECT queries, including practical examples and cost comparisons to improve query performance.
This tutorial walks through MySQL's EXPLAIN TYPE column, illustrating how different join types such as const, eq_ref, ref, range, and index affect query performance using concrete SQL examples and execution‑plan analysis on a sample table with a composite primary key.
This article demonstrates how to use MySQL's EXPLAIN statement to examine execution plans, interpret key fields such as possible_keys, key, rows, and Extra, and apply index adjustments—including adding and forcing indexes—to improve query performance while weighing sorting costs.
This article explains how slow MySQL queries degrade user experience, impact business operations, and consume resources, then details how to enable and interpret the slow query log, use EXPLAIN for query analysis, avoid common testing misconceptions, and apply four practical optimization strategies.
MySQL 8.3 introduces a new iterator‑aware JSON output for EXPLAIN and EXPLAIN ANALYZE, selectable via the explain_json_format_version variable, which aligns JSON with the tree format, provides richer execution statistics, and can be accessed programmatically through EXPLAIN INTO across all recent MySQL releases.
This article explains how adding an index to a status column in a tens‑of‑millions‑row MySQL table affects query performance, covering the basic index lookup process, extreme cases where full scans are chosen, selectivity, covering indexes, composite indexes, partitioning, and using EXPLAIN to verify execution plans.
This comprehensive guide explains MySQL indexing fundamentals, B+Tree advantages, index classifications, optimal creation strategies, and how to use EXPLAIN to diagnose and fine‑tune queries for maximum performance while avoiding common pitfalls.
This article demonstrates how a non‑unique indexed column that allows NULL values behaves with the != operator in MySQL, showing why null rows are omitted from result sets, how index usage changes, and how to rewrite queries with OR or UNION to obtain correct results while preserving performance.
This guide explains why slow queries occur in high‑traffic applications, outlines practical ways to monitor and fix them, and dives deep into using MySQL's EXPLAIN command to analyze index usage, interpret its output columns, and systematically improve query performance.
MySQL 9.0, released July 2 2024, introduces EXPLAIN JSON output stored in variables, native EVENT DDL statements, and two new performance‑schema tables for variable metadata, while deprecating the old variables_info columns and removing the mysql_native_password plugin in favor of caching_sha2_password, enhancing observability and security.
This article explains why slow queries occur in high‑traffic applications, outlines effective index‑optimization steps, and demonstrates how to use MySQL's EXPLAIN command to analyze execution plans, interpret each column, and improve database performance.
This article walks through generating tens of millions of rows in MySQL, then demonstrates a series of optimizations—including simple and covering indexes, data reduction, small‑table‑driven joins, and forced indexes—showing how each technique impacts query performance and EXPLAIN output.
This article walks through how to analyze MySQL slow queries using EXPLAIN, explains key EXPLAIN fields, and presents practical optimization techniques such as proper indexing, pagination tricks, join improvements, and ORDER BY/GROUP BY tuning to dramatically boost query performance.
This article explains MySQL's architecture, how to view storage engines and variables, demonstrates creating various indexes, describes why SQL optimization is needed, details the EXPLAIN plan keywords and index types, and provides practical best‑practice tips for single‑ and multi‑table query performance improvements.
This article recounts a real‑world incident where MySQL 5.7 chose a sub‑optimal index, causing a three‑second slow query, and explains how the team identified the root cause, used EXPLAIN and optimizer trace, and applied fixes such as forced index hints and data cleanup.
Version 8.3 of MySQL introduces tagged GTID replication, a selectable JSON EXPLAIN format version, enhanced thread‑pool plugin information, changes to binlog transaction dependency tracking and new CMake options, while removing several C API functions, the FLUSH HOSTS statement, and outdated replication flags.
This article explains the new EXPLAIN INTO clause introduced in MySQL 8.1 for storing JSON‑formatted EXPLAIN output in a user variable and the EXPLAIN FOR SCHEMA clause added in MySQL 8.2 for running EXPLAIN on other schemas, showing how to extract costs with JSON functions and automate collection with stored procedures.
This article explains why slow queries occur in high‑traffic MySQL databases, introduces the EXPLAIN statement, walks through its syntax and output columns, demonstrates how to interpret each field with concrete examples, and provides a practical workflow for optimizing indexes to eliminate performance bottlenecks.
This article explains how to use MySQL's EXPLAIN statement to view execution plans, demonstrates creating sample order and customer tables, walks through each column of the EXPLAIN output, and shows how indexes affect query performance, providing a practical reference for database optimization.
The article walks through a real‑world case of a slow MySQL query that took 8 seconds, explains why simple indexing wasn't enough, and demonstrates two successive rewrites using JOIN‑GROUP BY and NOT IN that reduced execution time to 0.7 seconds while detailing the EXPLAIN analysis.
In this article the author walks through a real‑world slow‑query case, using EXPLAIN, rewriting EXISTS clauses with JOIN + GROUP BY and swapping NOT EXISTS for NOT IN, ultimately reducing execution time from 8 seconds to 0.7 seconds while sharing key indexing insights.
This article explains MySQL index concepts, advantages, and pitfalls, walks through EXPLAIN output fields, offers practical tips for avoiding index invalidation and ORDER BY inefficiencies, and presents six real‑world slow‑query cases with step‑by‑step optimization solutions.
This article explains MySQL's basic architecture, demonstrates how to view and set storage engines, and provides comprehensive guidance on SQL optimization methods, index types, creation, usage, and performance analysis using EXPLAIN, helping readers improve query efficiency and avoid common pitfalls.
This article explains why slow SQL queries become a major risk for service stability, outlines a step‑by‑step investigation process using EXPLAIN, and presents multiple real‑world case studies with code snippets and optimization principles to quickly locate and resolve performance bottlenecks.
This article explains how MySQL's optimizer calculates execution costs for different indexes, why it may select a full table scan instead of an apparently better index, and shows how to use EXPLAIN and optimizer trace to reveal and improve the chosen execution plan.
This article explains how to use MySQL's EXPLAIN statement to analyze slow queries, detailing each output column, various select types, access methods, and common pitfalls, then provides practical optimization techniques such as proper indexing, query rewriting, index merging, handling COUNT, UNION, OFFSET, and table maintenance.
This article explains how MySQL calculates execution costs for different indexes using IO and CPU metrics, demonstrates with a sample table and queries, compares the optimizer's choices with actual performance, and shows how to use EXPLAIN and optimizer trace to fine‑tune query plans.
This article walks through why MySQL queries become slow, covering how to capture slow SQL, configure the slow‑query log, analyze execution plans with EXPLAIN, dive into PROFILE and OPTIMIZER_TRACE, and examine engine and system parameters that affect performance.
This guide explains MySQL indexes—what they are, their data structures, advantages and drawbacks, when to create them, various index types, how to interpret EXPLAIN output, common pitfalls that cause index loss, and practical optimization techniques for queries, joins, ordering, grouping, and slow‑query logging.
This article explains the definition, data structures, advantages, disadvantages, and appropriate usage scenarios of MySQL indexes, details primary, unique, single‑column and composite index types, analyzes common performance bottlenecks with EXPLAIN, demonstrates index creation, invalidation cases, query and join optimizations, and shows how to configure and use the slow‑query log.
This article explains how to enable MySQL's optimizer_trace feature, retrieve the detailed execution plan from the information_schema.OPTIMIZER_TRACE table, and interpret the cost‑based optimization phases (prepare, optimize, execute) to understand why the optimizer selects a particular index for a query.
This article explains why SQL queries become slow, how to capture slow queries using MySQL's slow query log, and provides detailed step‑by‑step methods for analyzing execution plans, profiling, optimizer tracing, and I/O parameters to identify and resolve performance bottlenecks.
This article explains how MySQL estimates the I/O and CPU costs of different indexes when executing COUNT(*) and other queries, demonstrates the calculations with a concrete example on a 100k‑row table, and shows why the optimizer sometimes picks a full‑table scan over a seemingly better index.
This article examines how MySQL decides whether to use an index or perform a full table scan for COUNT(*) and other queries, explains the IO and CPU cost model, demonstrates the calculations with a sample table, and shows how optimizer trace can reveal mismatches between estimated and actual performance.
This guide walks you through 13 practical MySQL techniques—from aggregating values with GROUP_CONCAT and measuring string length with CHAR_LENGTH, to locating substrings, replacing text, retrieving timestamps, bulk inserting data, handling duplicate keys, inspecting table structures, and using diagnostic commands like EXPLAIN and SHOW PROCESSLIST—complete with ready‑to‑run SQL examples and visual results.
This guide walks through MySQL performance tuning, covering the architectural tuning pyramid, query optimization techniques, slow‑query logging, detailed EXPLAIN execution‑plan analysis, and high‑performance indexing strategies to help you diagnose and accelerate database workloads.
This guide explains how to enable and read MySQL's slow query log, use EXPLAIN, profiling, and optimizer trace to pinpoint inefficient SQL, and presents ten classic problem patterns—such as implicit conversion, left‑most prefix violations, deep pagination, large IN lists, and file‑sort order‑by—with concrete code examples and practical optimization steps.
This article provides a comprehensive guide for MySQL developers on index selection, EXPLAIN interpretation, SQL best‑practice tips, lock handling, online schema changes, slow‑query analysis, and common performance pitfalls, offering practical commands and optimization strategies for large‑scale databases.
This article explains how to enable and configure MySQL's slow query log, set appropriate thresholds, use EXPLAIN to analyze execution plans, and apply index optimizations to dramatically reduce query execution time for large tables.
This guide explains how to enable MySQL slow query logging, set appropriate thresholds, locate inefficient SQL statements via logs and EXPLAIN, and optimize queries by using indexes and analyzing execution plans, with practical examples and code snippets.
This article explains why SQL performance becomes a bottleneck as data grows, outlines a systematic optimization workflow—including slow‑query detection, EXPLAIN analysis, profiling, tracing, and index tuning—and illustrates each step with concrete MySQL examples and best‑practice recommendations.
This article provides a comprehensive guide to MySQL index optimization, covering selectivity calculation, prefix length, composite index rules, EXPLAIN analysis, common slow‑query patterns, and practical sharding and partitioning techniques to improve query performance.
This article explains how MySQL's EXPLAIN command reveals execution plans through twelve key fields, demonstrates practical analysis of a slow query on a large table, and provides actionable tips such as adding or forcing indexes to dramatically improve query performance.
This article explains how to identify slow SQL statements, analyze execution plans with EXPLAIN, use profiling and tracing tools, and apply specific optimization techniques such as index tuning, query rewriting, and alternative storage solutions across a range of real‑world cases.
This guide presents a comprehensive set of MySQL optimization techniques—including proper use of EXPLAIN, limiting IN clause size, avoiding SELECT *, using LIMIT 1, minimizing sorting, replacing OR with UNION ALL, preferring UNION ALL over UNION, eliminating ORDER BY RAND(), distinguishing IN versus EXISTS, applying efficient pagination, segmenting large scans, avoiding NULL checks and leading wildcards, rewriting expressions, preventing implicit type conversion, respecting composite index leftmost rules, forcing indexes, handling range queries, and optimizing JOINs—to dramatically improve query performance.
This comprehensive guide explains MySQL's architecture, storage engines, and the critical role of indexes, walks through the SQL parsing process, details how to read and interpret EXPLAIN output, and provides practical optimization examples for single‑table and multi‑table queries.
This guide walks through essential MySQL performance tuning methods, from identifying slow queries via logs and EXPLAIN analysis to interpreting Extra information, using profiling and optimizer trace, and applying concrete index, query, and schema adjustments for common scenarios such as left‑most matching, implicit conversion, large pagination, IN‑order‑by, and complex queries.
This article walks through ten typical scenarios where MySQL indexes fail—covering left‑most prefix violations, SELECT *, calculations, functions, type mismatches, LIKE patterns, column comparisons, OR, NOT IN/NOT EXISTS, and ORDER BY—showing why each occurs and how to keep indexes effective.
This article explains TiDB's SQL layer architecture, details how SQL requests are processed and optimized, demonstrates the use of EXPLAIN and EXPLAIN ANALYZE, and presents two real‑world case studies that illustrate common performance pitfalls and practical optimization techniques.
This article explains MySQL's experimental EXPLAIN FORMAT=TREE feature and the later EXPLAIN ANALYZE extension, showing how they present execution plans, estimated costs, actual runtime metrics, and how to interpret the tree output for query optimization.
This article explains the principles, advantages, and pitfalls of MySQL composite indexes, covering the left‑most matching rule, field order effects, when single columns can use an index, and whether a composite index can replace single‑column indexes, with practical EXPLAIN examples.
A practical MySQL InnoDB test shows that count(1) and count(*) have almost identical performance, explains the underlying index usage, and clarifies why MyISAM can count rows faster due to its storage design.
This article explains why SQL queries can become slow, outlines MySQL's internal architecture, demonstrates how to use the EXPLAIN statement to view execution plans, and interprets key fields such as type, key, and Extra to help developers identify and optimize performance bottlenecks.
This article explains why SQL queries become slow in MySQL, describes the server architecture, details how to use the EXPLAIN statement to interpret execution plans, and outlines how to read and optimize key fields such as type, key, and extra for better performance.
This article explains MySQL's architecture, the server and storage‑engine layers, query execution phases, status states, query cache behavior, the optimizer's parsing and planning steps, EXPLAIN output fields, the cost model, and why the optimizer selects index_author_id instead of index_title for a given query.
This article explains what an execution plan is, how to use the EXPLAIN keyword in MySQL 5.7, interprets each column of the EXPLAIN output—including id, select_type, table, type, possible_keys, key, key_len, rows, and Extra—provides detailed examples of different query scenarios, and shows how optimizer settings like derived_merge affect the plan.
This article demonstrates how to create and use a sample employees table, explains composite index structures, and provides ten concrete MySQL index best‑practice guidelines—covering full‑value matches, leftmost‑prefix rules, avoiding functions, range conditions, covering indexes, inequality, NULL checks, leading wildcards, type conversions, and OR usage—each illustrated with EXPLAIN output and code examples.
This article explains the fundamentals of MySQL indexes, focusing on B+Tree structures, differences between MyISAM and InnoDB implementations, practical indexing strategies, configuration and SQL tuning tips, and provides a detailed case study with EXPLAIN analysis to help developers design efficient indexes.
This article provides a comprehensive overview of Hive's execution engines—including MapReduce, Tez, and Spark—detailing their architectures, the six-stage Hive SQL compilation process, practical Explain syntax examples, and extensive tuning parameters for each engine to improve performance in big‑data environments.
This article examines why a MySQL composite index on (first_name, last_name) initially fails to be used for ordering, demonstrates how adding a range predicate reduces the scanned row count, and explains the threshold at which MySQL switches from filesort to index‑based retrieval.
This article explains MySQL index fundamentals, advantages, types, and structures, demonstrates how to interpret EXPLAIN output, and presents six real‑world slow‑query cases with step‑by‑step optimizations, including index creation guidelines, invalidation pitfalls, ORDER BY tuning, and join improvements.
This article explains the purpose and interpretation of each column in MySQL's EXPLAIN output, covering identifiers, select types, table sources, partition info, access types, possible keys, actual keys, key lengths, row estimates, filtering percentages, and extra execution details, with visual examples and code snippets.
This comprehensive guide walks you through MySQL performance tuning, covering how to monitor server status, identify slow queries, use EXPLAIN for execution plans, create and manage various index types, and apply practical SQL optimizations such as import tricks, insert batching, efficient GROUP BY/ORDER BY, and pagination improvements.
This article explains why a query that uses an index can still be slow, demonstrates how to diagnose index usage and row scans with EXPLAIN and the slow query log, and presents optimization techniques such as composite indexes, index condition pushdown, and virtual columns.
This article, the fourth in a MySQL fundamentals series, explains how to diagnose and optimize slow SQL statements using SHOW STATUS, the slow‑query log, SHOW PROCESSLIST, and EXPLAIN, then details index types, creation, usage rules, and how to analyze, check, and optimize tables with MySQL commands.
