Table of Contents
SELECT
and Other StatementsEXPLAIN
SELECT
QueriesWHERE
Clause OptimizationIS NULL
OptimizationLEFT JOIN
and RIGHT JOIN
OptimizationORDER BY
OptimizationGROUP BY
OptimizationDISTINCT
OptimizationLIMIT
OptimizationINSERT
StatementsUPDATE
StatementsDELETE
StatementsMyISAM
Key CacheMyISAM
Index Statistics CollectionOptimization is a complex task because ultimately it requires understanding of the entire system to be optimized. Although it may be possible to perform some local optimizations with little knowledge of your system or application, the more optimal you want your system to become, the more you must know about it.
This chapter tries to explain and give some examples of different ways to optimize MySQL. Remember, however, that there are always additional ways to make the system even faster, although they may require increasing effort to achieve.
The most important factor in making a system fast is its basic design. You must also know what kinds of processing your system is doing, and what its bottlenecks are. In most cases, system bottlenecks arise from these sources:
Disk seeks. It takes time for the disk to find a piece of data. With modern disks, the mean time for this is usually lower than 10ms, so we can in theory do about 100 seeks a second. This time improves slowly with new disks and is very hard to optimize for a single table. The way to optimize seek time is to distribute the data onto more than one disk.
Disk reading and writing. When the disk is at the correct position, we need to read the data. With modern disks, one disk delivers at least 10–20MB/s throughput. This is easier to optimize than seeks because you can read in parallel from multiple disks.
CPU cycles. When we have the data in main memory, we need to process it to get our result. Having small tables compared to the amount of memory is the most common limiting factor. But with small tables, speed is usually not the problem.
Memory bandwidth. When the CPU needs more data than can fit in the CPU cache, main memory bandwidth becomes a bottleneck. This is an uncommon bottleneck for most systems, but one to be aware of.
MySQL Enterprise For instant notification of system bottlenecks subscribe to the MySQL Enterprise Monitor. For more information see http://www.mysql.com/products/enterprise/advisors.html.
When using the MyISAM
storage engine, MySQL
uses extremely fast table locking that allows multiple readers
or a single writer. The biggest problem with this storage engine
occurs when you have a steady stream of mixed updates and slow
selects on a single table. If this is a problem for certain
tables, you can use another storage engine for them. See
Chapter 13, Storage Engines.
MySQL can work with both transactional and non-transactional
tables. To make it easier to work smoothly with
non-transactional tables (which cannot roll back if something
goes wrong), MySQL has the following rules. Note that these
rules apply only when you use the
IGNORE
specifier for
INSERT
or UPDATE
.
All columns have default values.
If you insert an inappropriate or out-of-range value into a column, MySQL sets the column to the “best possible value” instead of reporting an error. For numerical values, this is 0, the smallest possible value or the largest possible value. For strings, this is either the empty string or as much of the string as can be stored in the column.
All calculated expressions return a value that can be used
instead of signaling an error condition. For example, 1/0
returns NULL
.
To change the preceding behaviors, you can enable stricter data
handling by setting the server SQL mode appropriately. For more
information about data handling, see
Section 1.8.6, “How MySQL Deals with Constraints”,
Section 5.1.6, “SQL Modes”, and Section 12.2.4, “INSERT
Syntax”.
Because all SQL servers implement different parts of standard SQL, it takes work to write portable database applications. It is very easy to achieve portability for very simple selects and inserts, but becomes more difficult the more capabilities you require. If you want an application that is fast with many database systems, it becomes even more difficult.
All database systems have some weak points. That is, they have different design compromises that lead to different behavior.
To make a complex application portable, you need to determine which SQL servers it must work with, and then determine what features those servers support. You can use the MySQL crash-me program to find functions, types, and limits that you can use with a selection of database servers. crash-me does not check for every possible feature, but it is still reasonably comprehensive, performing about 450 tests. An example of the type of information crash-me can provide is that you should not use column names that are longer than 18 characters if you want to be able to use Informix or DB2.
The crash-me program and the MySQL benchmarks
are all very database independent. By taking a look at how they
are written, you can get a feeling for what you must do to make
your own applications database independent. The programs can be
found in the sql-bench
directory of MySQL
source distributions. They are written in Perl and use the DBI
database interface. Use of DBI in itself solves part of the
portability problem because it provides database-independent
access methods. See Section 7.1.4, “The MySQL Benchmark Suite”.
If you strive for database independence, you need to get a good
feeling for each SQL server's bottlenecks. For example, MySQL is
very fast in retrieving and updating rows for
MyISAM
tables, but has a problem in mixing
slow readers and writers on the same table. Transactional
database systems in general are not very good at generating
summary tables from log tables, because in this case row locking
is almost useless.
MySQL Enterprise For expert advice on choosing the database engine suitable to your circumstances subscribe to the MySQL Enterprise Monitor. For more information see http://www.mysql.com/products/enterprise/advisors.html.
To make your application really database independent, you should define an easily extendable interface through which you manipulate your data. For example, C++ is available on most systems, so it makes sense to use a C++ class-based interface to the databases.
If you use some feature that is specific to a given database
system (such as the REPLACE
statement, which
is specific to MySQL), you should implement the same feature for
other SQL servers by coding an alternative method. Although the
alternative might be slower, it enables the other servers to
perform the same tasks.
With MySQL, you can use the /*! */
syntax to
add MySQL-specific keywords to a statement. The code inside
/* */
is treated as a comment (and ignored)
by most other SQL servers. For information about writing
comments, see Section 8.5, “Comment Syntax”.
If high performance is more important than exactness, as for some Web applications, it is possible to create an application layer that caches all results to give you even higher performance. By letting old results expire after a while, you can keep the cache reasonably fresh. This provides a method to handle high load spikes, in which case you can dynamically increase the cache size and set the expiration timeout higher until things get back to normal.
In this case, the table creation information should contain information about the initial cache size and how often the table should normally be refreshed.
An attractive alternative to implementing an application cache is to use the MySQL query cache. By enabling the query cache, the server handles the details of determining whether a query result can be reused. This simplifies your application. See Section 7.5.3, “The MySQL Query Cache”.
This section describes an early application for MySQL.
During MySQL initial development, the features of MySQL were made to fit our largest customer, which handled data warehousing for a couple of the largest retailers in Sweden.
From all stores, we got weekly summaries of all bonus card transactions, and were expected to provide useful information for the store owners to help them find how their advertising campaigns were affecting their own customers.
The volume of data was quite huge (about seven million summary transactions per month), and we had data for 4–10 years that we needed to present to the users. We got weekly requests from our customers, who wanted instant access to new reports from this data.
We solved this problem by storing all information per month in compressed “transaction tables.” We had a set of simple macros that generated summary tables grouped by different criteria (product group, customer id, store, and so on) from the tables in which the transactions were stored. The reports were Web pages that were dynamically generated by a small Perl script. This script parsed a Web page, executed the SQL statements in it, and inserted the results. We would have used PHP or mod_perl instead, but they were not available at the time.
For graphical data, we wrote a simple tool in C that could process SQL query results and produce GIF images based on those results. This tool also was dynamically executed from the Perl script that parses the Web pages.
In most cases, a new report could be created simply by copying an existing script and modifying the SQL query that it used. In some cases, we needed to add more columns to an existing summary table or generate a new one. This also was quite simple because we kept all transaction-storage tables on disk. (This amounted to about 50GB of transaction tables and 200GB of other customer data.)
We also let our customers access the summary tables directly with ODBC so that the advanced users could experiment with the data themselves.
This system worked well and we had no problems handling the data with quite modest Sun Ultra SPARCstation hardware (2×200MHz). Eventually the system was migrated to Linux.
This benchmark suite is meant to tell any user what operations a
given SQL implementation performs well or poorly. You can get a
good idea for how the benchmarks work by looking at the code and
results in the sql-bench
directory in any
MySQL source distribution.
Note that this benchmark is single-threaded, so it measures the minimum time for the operations performed. We plan to add multi-threaded tests to the benchmark suite in the future.
To use the benchmark suite, the following requirements must be satisfied:
The benchmark suite is provided with MySQL source distributions. You can either download a released distribution from http://dev.mysql.com/downloads/, or use the current development source tree. (See Section 2.9.3, “Installing from the Development Source Tree”.)
The benchmark scripts are written in Perl and use the Perl
DBI module to access database servers, so DBI must be
installed. You also need the server-specific DBD drivers for
each of the servers you want to test. For example, to test
MySQL, PostgreSQL, and DB2, you must have the
DBD::mysql
, DBD::Pg
,
and DBD::DB2
modules installed. See
Section 2.15, “Perl Installation Notes”.
After you obtain a MySQL source distribution, you can find the
benchmark suite located in its sql-bench
directory. To run the benchmark tests, build MySQL, and then
change location into the sql-bench
directory and execute the run-all-tests
script:
shell>cd sql-bench
shell>perl run-all-tests --server=
server_name
server_name
should be the name of one
of the supported servers. To get a list of all options and
supported servers, invoke this command:
shell> perl run-all-tests --help
The crash-me script also is located in the
sql-bench
directory.
crash-me tries to determine what features a
database system supports and what its capabilities and
limitations are by actually running queries. For example, it
determines:
What data types are supported
How many indexes are supported
What functions are supported
How big a query can be
How big a VARCHAR
column can be
You can find the results from crash-me for many different database servers at http://dev.mysql.com/tech-resources/crash-me.php. For more information about benchmark results, visit http://dev.mysql.com/tech-resources/benchmarks/.
You should definitely benchmark your application and database to find out where the bottlenecks are. After fixing one bottleneck (or by replacing it with a “dummy” module), you can proceed to identify the next bottleneck. Even if the overall performance for your application currently is acceptable, you should at least make a plan for each bottleneck and decide how to solve it if someday you really need the extra performance.
For examples of portable benchmark programs, look at those in the MySQL benchmark suite. See Section 7.1.4, “The MySQL Benchmark Suite”. You can take any program from this suite and modify it for your own needs. By doing this, you can try different solutions to your problem and test which really is fastest for you.
Another free benchmark suite is the Open Source Database Benchmark, available at http://osdb.sourceforge.net/.
It is very common for a problem to occur only when the system is very heavily loaded. We have had many customers who contact us when they have a (tested) system in production and have encountered load problems. In most cases, performance problems turn out to be due to issues of basic database design (for example, table scans are not good under high load) or problems with the operating system or libraries. Most of the time, these problems would be much easier to fix if the systems were not already in production.
To avoid problems like this, you should put some effort into benchmarking your whole application under the worst possible load. You can use Super Smack, available at http://jeremy.zawodny.com/mysql/super-smack/. As suggested by its name, it can bring a system to its knees, so make sure to use it only on your development systems.
EXPLAIN
SELECT
QueriesWHERE
Clause OptimizationIS NULL
OptimizationLEFT JOIN
and RIGHT JOIN
OptimizationORDER BY
OptimizationGROUP BY
OptimizationDISTINCT
OptimizationLIMIT
OptimizationINSERT
StatementsUPDATE
StatementsDELETE
Statements
First, one factor affects all statements: The more complex your
permissions setup, the more overhead you have. Using simpler
permissions when you issue GRANT
statements
enables MySQL to reduce permission-checking overhead when clients
execute statements. For example, if you do not grant any
table-level or column-level privileges, the server need not ever
check the contents of the tables_priv
and
columns_priv
tables. Similarly, if you place no
resource limits on any accounts, the server does not have to
perform resource counting. If you have a very high
statement-processing load, it may be worth the time to use a
simplified grant structure to reduce permission-checking overhead.
If your problem is with a specific MySQL expression or function,
you can perform a timing test by invoking the
BENCHMARK()
function using the
mysql client program. Its syntax is
BENCHMARK(
.
The return value is always zero, but mysql
prints a line displaying approximately how long the statement took
to execute. For example:
loop_count
,expression
)
mysql> SELECT BENCHMARK(1000000,1+1);
+------------------------+
| BENCHMARK(1000000,1+1) |
+------------------------+
| 0 |
+------------------------+
1 row in set (0.32 sec)
This result was obtained on a Pentium II 400MHz system. It shows that MySQL can execute 1,000,000 simple addition expressions in 0.32 seconds on that system.
All MySQL functions should be highly optimized, but there may be
some exceptions. BENCHMARK()
is an
excellent tool for finding out if some function is a problem for
your queries.
The EXPLAIN
statement can be used either as a
synonym for DESCRIBE
or as a way to obtain
information about how MySQL executes a SELECT
statement:
EXPLAIN
is synonymous
with tbl_name
DESCRIBE
or
tbl_name
SHOW COLUMNS FROM
:
tbl_name
EXPLAIN tbl_name
When you precede a SELECT
statement with
the keyword EXPLAIN
, MySQL displays
information from the optimizer about the query execution
plan. That is, MySQL explains how it would process the
SELECT
, including information about how
tables are joined and in which order:
EXPLAIN [EXTENDED] SELECT select_options
This section describes the second use of
EXPLAIN
for obtaining query execution plan
information. For a description of the
DESCRIBE
and SHOW COLUMNS
statements, see Section 12.3.1, “DESCRIBE
Syntax”, and
Section 12.5.4.3, “SHOW COLUMNS
Syntax”.
With the help of EXPLAIN
, you can see where
you should add indexes to tables to get a faster
SELECT
that uses indexes to find rows. You
can also use EXPLAIN
to check whether the
optimizer joins the tables in an optimal order. To force the
optimizer to use a join order corresponding to the order in
which the tables are named in the SELECT
statement, begin the statement with SELECT
STRAIGHT_JOIN
rather than just
SELECT
.
If you have a problem with indexes not being used when you
believe that they should be, you should run ANALYZE
TABLE
to update table statistics such as cardinality
of keys, that can affect the choices the optimizer makes. See
Section 12.5.2.1, “ANALYZE TABLE
Syntax”.
EXPLAIN
returns a row of information for each
table used in the SELECT
statement. The
tables are listed in the output in the order that MySQL would
read them while processing the query. MySQL resolves all joins
using a single-sweep multi-join method.
This means that MySQL reads a row from the first table, and then
finds a matching row in the second table, the third table, and
so on. When all tables are processed, MySQL outputs the selected
columns and backtracks through the table list until a table is
found for which there are more matching rows. The next row is
read from this table and the process continues with the next
table.
In MySQL version 4.1, the EXPLAIN
output
format was changed to work better with constructs such as
UNION
statements, subqueries, and derived
tables. Most notable is the addition of two new columns:
id
and select_type
. You do
not see these columns when using servers older than MySQL 4.1.
EXPLAIN
syntax also was augmented to allow
the EXTENDED
keyword. When this keyword is
used, EXPLAIN
produces extra information that
can be viewed by issuing a SHOW WARNINGS
statement following the EXPLAIN
statement.
This information displays how the optimizer qualifies table and
column names in the SELECT
statement, what
the SELECT
looks like after the application
of rewriting and optimization rules, and possibly other notes
about the optimization process.
Each output row from EXPLAIN
provides
information about one table, and each row contains the following
columns:
id
The SELECT
identifier. This is the
sequential number of the SELECT
within
the query.
select_type
The type of SELECT
, which can be any of
those shown in the following table:
SIMPLE | Simple SELECT (not using UNION or
subqueries) |
PRIMARY | Outermost SELECT |
UNION | Second or later SELECT statement in a
UNION |
DEPENDENT UNION | Second or later SELECT statement in a
UNION , dependent on outer query |
UNION RESULT | Result of a UNION . |
SUBQUERY | First SELECT in subquery |
DEPENDENT SUBQUERY | First SELECT in subquery, dependent on outer query |
DERIVED | Derived table SELECT (subquery in
FROM clause) |
UNCACHEABLE SUBQUERY | A subquery for which the result cannot be cached and must be re-evaluated for each row of the outer query |
DEPENDENT
typically signifies the use of
a correlated subquery. See
Section 12.2.8.7, “Correlated Subqueries”.
“DEPENDENT SUBQUERY” evaluation differs from
UNCACHEABLE SUBQUERY
evaluation. For
“DEPENDENT SUBQUERY”, the subquery is
re-evaluated only once for each set of different values of
the variables from its outer context. For
UNCACHEABLE SUBQUERY
, the subquery is
re-evaluated for each row of the outer context. Cacheability
of subqueries is subject to the restrictions detailed in
Section 7.5.3.1, “How the Query Cache Operates”. For example, referring to
user variables makes a subquery uncacheable.
table
The table to which the row of output refers.
type
The join type. The different join types are listed here, ordered from the best type to the worst:
The table has only one row (= system table). This is a
special case of the const
join type.
The table has at most one matching row, which is read at
the start of the query. Because there is only one row,
values from the column in this row can be regarded as
constants by the rest of the optimizer.
const
tables are very fast because
they are read only once.
const
is used when you compare all
parts of a PRIMARY KEY
or
UNIQUE
index to constant values. In
the following queries,
tbl_name
can be used as a
const
table:
SELECT * FROMtbl_name
WHEREprimary_key
=1; SELECT * FROMtbl_name
WHEREprimary_key_part1
=1 ANDprimary_key_part2
=2;
eq_ref
One row is read from this table for each combination of
rows from the previous tables. Other than the
system
and const
types, this is the best possible join type. It is used
when all parts of an index are used by the join and the
index is a PRIMARY KEY
or
UNIQUE
index.
eq_ref
can be used for indexed
columns that are compared using the =
operator. The comparison value can be a constant or an
expression that uses columns from tables that are read
before this table. In the following examples, MySQL can
use an eq_ref
join to process
ref_table
:
SELECT * FROMref_table
,other_table
WHEREref_table
.key_column
=other_table
.column
; SELECT * FROMref_table
,other_table
WHEREref_table
.key_column_part1
=other_table
.column
ANDref_table
.key_column_part2
=1;
ref
All rows with matching index values are read from this
table for each combination of rows from the previous
tables. ref
is used if the join uses
only a leftmost prefix of the key or if the key is not a
PRIMARY KEY
or
UNIQUE
index (in other words, if the
join cannot select a single row based on the key value).
If the key that is used matches only a few rows, this is
a good join type.
ref
can be used for indexed columns
that are compared using the =
or
<=>
operator. In the following
examples, MySQL can use a ref
join to
process ref_table
:
SELECT * FROMref_table
WHEREkey_column
=expr
; SELECT * FROMref_table
,other_table
WHEREref_table
.key_column
=other_table
.column
; SELECT * FROMref_table
,other_table
WHEREref_table
.key_column_part1
=other_table
.column
ANDref_table
.key_column_part2
=1;
fulltext
The join is performed using a
FULLTEXT
index.
ref_or_null
This join type is like ref
, but with
the addition that MySQL does an extra search for rows
that contain NULL
values. This join
type optimization was added for MySQL 4.1.1 and is used
mostly when resolving subqueries. In the following
examples, MySQL can use a ref_or_null
join to process ref_table
:
SELECT * FROMref_table
WHEREkey_column
=expr
ORkey_column
IS NULL;
unique_subquery
This type replaces ref
for some
IN
subqueries of the following form:
value
IN (SELECTprimary_key
FROMsingle_table
WHEREsome_expr
)
unique_subquery
is just an index
lookup function that replaces the subquery completely
for better efficiency.
index_subquery
This join type is similar to
unique_subquery
. It replaces
IN
subqueries, but it works for
non-unique indexes in subqueries of the following form:
value
IN (SELECTkey_column
FROMsingle_table
WHEREsome_expr
)
range
Only rows that are in a given range are retrieved, using
an index to select the rows. The key
column in the output row indicates which index is used.
The key_len
contains the longest key
part that was used. The ref
column is
NULL
for this type.
range
can be used when a key column
is compared to a constant using any of the
=
,
<>
,
>
,
>=
,
<
,
<=
,
IS NULL
,
<=>
,
BETWEEN
, or
IN()
operators:
SELECT * FROMtbl_name
WHEREkey_column
= 10; SELECT * FROMtbl_name
WHEREkey_column
BETWEEN 10 and 20; SELECT * FROMtbl_name
WHEREkey_column
IN (10,20,30); SELECT * FROMtbl_name
WHEREkey_part1
= 10 ANDkey_part2
IN (10,20,30);
index
This join type is the same as ALL
,
except that only the index tree is scanned. This usually
is faster than ALL
because the index
file usually is smaller than the data file.
MySQL can use this join type when the query uses only columns that are part of a single index.
ALL
A full table scan is done for each combination of rows
from the previous tables. This is normally not good if
the table is the first table not marked
const
, and usually
very bad in all other cases.
Normally, you can avoid ALL
by adding
indexes that allow row retrieval from the table based on
constant values or column values from earlier tables.
possible_keys
The possible_keys
column indicates which
indexes MySQL can choose from use to find the rows in this
table. Note that this column is totally independent of the
order of the tables as displayed in the output from
EXPLAIN
. That means that some of the keys
in possible_keys
might not be usable in
practice with the generated table order.
If this column is NULL
, there are no
relevant indexes. In this case, you may be able to improve
the performance of your query by examining the
WHERE
clause to check whether it refers
to some column or columns that would be suitable for
indexing. If so, create an appropriate index and check the
query with EXPLAIN
again. See
Section 12.1.2, “ALTER TABLE
Syntax”.
To see what indexes a table has, use SHOW INDEX
FROM
.
tbl_name
key
The key
column indicates the key (index)
that MySQL actually decided to use. If MySQL decides to use
one of the possible_keys
indexes to look
up rows, that index is listed as the key value.
It is possible that key
will name an
index that is not present in the
possible_keys
value. This can happen if
none of the possible_keys
indexes are
suitable for looking up rows, but all the columns selected
by the query are columns of some other index. That is, the
named index covers the selected columns, so although it is
not used to determine which rows to retrieve, an index scan
is more efficient than a data row scan.
For InnoDB
, a secondary index might cover
the selected columns even if the query also selects the
primary key because InnoDB
stores the
primary key value with each secondary index. If
key
is NULL
, MySQL
found no index to use for executing the query more
efficiently.
To force MySQL to use or ignore an index listed in the
possible_keys
column, use FORCE
INDEX
, USE INDEX
, or
IGNORE INDEX
in your query. See
Section 12.2.7.2, “Index Hint Syntax”.
For MyISAM
and BDB
tables, running ANALYZE TABLE
helps the
optimizer choose better indexes. For
MyISAM
tables, myisamchk
--analyze does the same. See
Section 12.5.2.1, “ANALYZE TABLE
Syntax”, and
Section 5.7.4, “Table Maintenance and Crash Recovery”.
key_len
The key_len
column indicates the length
of the key that MySQL decided to use. The length is
NULL
if the key
column
says NULL
. Note that the value of
key_len
enables you to determine how many
parts of a multiple-part key MySQL actually uses.
ref
The ref
column shows which columns or
constants are compared to the index named in the
key
column to select rows from the table.
rows
The rows
column indicates the number of
rows MySQL believes it must examine to execute the query.
Extra
This column contains additional information about how MySQL
resolves the query. The following list explains the values
that can appear in this column. If you want to make your
queries as fast as possible, you should look out for
Extra
values of Using
filesort
and Using temporary
.
Distinct
MySQL is looking for distinct values, so it stops searching for more rows for the current row combination after it has found the first matching row.
Impossible WHERE noticed after reading const
tables
MySQL has read all const
(and
system
) tables and notice that the
WHERE
clause is always false.
No tables
The query has no FROM
clause, or has
a FROM DUAL
clause.
Not exists
MySQL was able to do a LEFT JOIN
optimization on the query and does not examine more rows
in this table for the previous row combination after it
finds one row that matches the LEFT
JOIN
criteria. Here is an example of the type
of query that can be optimized this way:
SELECT * FROM t1 LEFT JOIN t2 ON t1.id=t2.id WHERE t2.id IS NULL;
Assume that t2.id
is defined as
NOT NULL
. In this case, MySQL scans
t1
and looks up the rows in
t2
using the values of
t1.id
. If MySQL finds a matching row
in t2
, it knows that
t2.id
can never be
NULL
, and does not scan through the
rest of the rows in t2
that have the
same id
value. In other words, for
each row in t1
, MySQL needs to do
only a single lookup in t2
,
regardless of how many rows actually match in
t2
.
range checked for each record (index map:
N
)
MySQL found no good index to use, but found that some of
indexes might be used after column values from preceding
tables are known. For each row combination in the
preceding tables, MySQL checks whether it is possible to
use a range
access method to retrieve
rows. The applicability criteria are as described in
Section 7.2.5, “Range Optimization”, with the exception
that all column values for the preceding table are known
and considered to be constants.
This is not very fast, but is faster than performing a join with no index at all.
Select tables optimized away
The query contained only aggregate functions
(MIN()
,
MAX()
) that were all
resolved using an index, or
COUNT(*)
for
MyISAM
, and no GROUP
BY
clause. The optimizer determined that only
one row should be returned.
Using filesort
MySQL must do an extra pass to find out how to retrieve
the rows in sorted order. The sort is done by going
through all rows according to the join type and storing
the sort key and pointer to the row for all rows that
match the WHERE
clause. The keys then
are sorted and the rows are retrieved in sorted order.
See Section 7.2.8, “ORDER BY
Optimization”.
Using index
The column information is retrieved from the table using only information in the index tree without having to do an additional seek to read the actual row. This strategy can be used when the query uses only columns that are part of a single index.
Using temporary
To resolve the query, MySQL needs to create a temporary
table to hold the result. This typically happens if the
query contains GROUP BY
and
ORDER BY
clauses that list columns
differently.
Using where
A WHERE
clause is used to restrict
which rows to match against the next table or send to
the client. Unless you specifically intend to fetch or
examine all rows from the table, you may have something
wrong in your query if the Extra
value is not Using where
and the
table join type is ALL
or
index
.
Using index for group-by
Similar to the Using index
way of
accessing a table, Using index for
group-by
indicates that MySQL found an index
that can be used to retrieve all columns of a
GROUP BY
or
DISTINCT
query without any extra disk
access to the actual table. Additionally, the index is
used in the most efficient way so that for each group,
only a few index entries are read. For details, see
Section 7.2.9, “GROUP BY
Optimization”.
You can get a good indication of how good a join is by taking
the product of the values in the rows
column
of the EXPLAIN
output. This should tell you
roughly how many rows MySQL must examine to execute the query.
If you restrict queries with the
max_join_size
system variable, this row
product also is used to determine which multiple-table
SELECT
statements to execute and which to
abort. See Section 7.5.2, “Tuning Server Parameters”.
The following example shows how a multiple-table join can be
optimized progressively based on the information provided by
EXPLAIN
.
Suppose that you have the SELECT
statement
shown here and that you plan to examine it using
EXPLAIN
:
EXPLAIN SELECT tt.TicketNumber, tt.TimeIn, tt.ProjectReference, tt.EstimatedShipDate, tt.ActualShipDate, tt.ClientID, tt.ServiceCodes, tt.RepetitiveID, tt.CurrentProcess, tt.CurrentDPPerson, tt.RecordVolume, tt.DPPrinted, et.COUNTRY, et_1.COUNTRY, do.CUSTNAME FROM tt, et, et AS et_1, do WHERE tt.SubmitTime IS NULL AND tt.ActualPC = et.EMPLOYID AND tt.AssignedPC = et_1.EMPLOYID AND tt.ClientID = do.CUSTNMBR;
For this example, make the following assumptions:
The columns being compared have been declared as follows:
Table | Column | Data Type |
tt | ActualPC | CHAR(10) |
tt | AssignedPC | CHAR(10) |
tt | ClientID | CHAR(10) |
et | EMPLOYID | CHAR(15) |
do | CUSTNMBR | CHAR(15) |
The tables have the following indexes:
Table | Index |
tt | ActualPC |
tt | AssignedPC |
tt | ClientID |
et | EMPLOYID (primary key) |
do | CUSTNMBR (primary key) |
The tt.ActualPC
values are not evenly
distributed.
Initially, before any optimizations have been performed, the
EXPLAIN
statement produces the following
information:
table type possible_keys key key_len ref rows Extra et ALL PRIMARY NULL NULL NULL 74 do ALL PRIMARY NULL NULL NULL 2135 et_1 ALL PRIMARY NULL NULL NULL 74 tt ALL AssignedPC, NULL NULL NULL 3872 ClientID, ActualPC range checked for each record (key map: 35)
Because type
is ALL
for
each table, this output indicates that MySQL is generating a
Cartesian product of all the tables; that is, every combination
of rows. This takes quite a long time, because the product of
the number of rows in each table must be examined. For the case
at hand, this product is 74 × 2135 × 74 × 3872
= 45,268,558,720 rows. If the tables were bigger, you can only
imagine how long it would take.
One problem here is that MySQL can use indexes on columns more
efficiently if they are declared as the same type and size. (For
ISAM
tables, indexes may not be used at all
unless the columns are declared the same.) In this context,
VARCHAR
and CHAR
are
considered the same if they are declared as the same size.
tt.ActualPC
is declared as
CHAR(10)
and et.EMPLOYID
is CHAR(15)
, so there is a length mismatch.
To fix this disparity between column lengths, use ALTER
TABLE
to lengthen ActualPC
from 10
characters to 15 characters:
mysql> ALTER TABLE tt MODIFY ActualPC VARCHAR(15);
Now tt.ActualPC
and
et.EMPLOYID
are both
VARCHAR(15)
. Executing the
EXPLAIN
statement again produces this result:
table type possible_keys key key_len ref rows Extra tt ALL AssignedPC, NULL NULL NULL 3872 Using ClientID, where ActualPC do ALL PRIMARY NULL NULL NULL 2135 range checked for each record (key map: 1) et_1 ALL PRIMARY NULL NULL NULL 74 range checked for each record (key map: 1) et eq_ref PRIMARY PRIMARY 15 tt.ActualPC 1
This is not perfect, but is much better: The product of the
rows
values is less by a factor of 74. This
version executes in a couple of seconds.
A second alteration can be made to eliminate the column length
mismatches for the tt.AssignedPC =
et_1.EMPLOYID
and tt.ClientID =
do.CUSTNMBR
comparisons:
mysql>ALTER TABLE tt MODIFY AssignedPC VARCHAR(15),
->MODIFY ClientID VARCHAR(15);
After that modification, EXPLAIN
produces the
output shown here:
table type possible_keys key key_len ref rows Extra et ALL PRIMARY NULL NULL NULL 74 tt ref AssignedPC, ActualPC 15 et.EMPLOYID 52 Using ClientID, where ActualPC et_1 eq_ref PRIMARY PRIMARY 15 tt.AssignedPC 1 do eq_ref PRIMARY PRIMARY 15 tt.ClientID 1
At this point, the query is optimized almost as well as
possible. The remaining problem is that, by default, MySQL
assumes that values in the tt.ActualPC
column
are evenly distributed, and that is not the case for the
tt
table. Fortunately, it is easy to tell
MySQL to analyze the key distribution:
mysql> ANALYZE TABLE tt;
With the additional index information, the join is perfect and
EXPLAIN
produces this result:
table type possible_keys key key_len ref rows Extra tt ALL AssignedPC NULL NULL NULL 3872 Using ClientID, where ActualPC et eq_ref PRIMARY PRIMARY 15 tt.ActualPC 1 et_1 eq_ref PRIMARY PRIMARY 15 tt.AssignedPC 1 do eq_ref PRIMARY PRIMARY 15 tt.ClientID 1
Note that the rows
column in the output from
EXPLAIN
is an educated guess from the MySQL
join optimizer. You should check whether the numbers are even
close to the truth by comparing the rows
product with the actual number of rows that the query returns.
If the numbers are quite different, you might get better
performance by using STRAIGHT_JOIN
in your
SELECT
statement and trying to list the
tables in a different order in the FROM
clause.
MySQL Enterprise Subscribers to the MySQL Enterprise Monitor regularly receive expert advice on optimization. For more information see http://www.mysql.com/products/enterprise/advisors.html.
In most cases, you can estimate query performance by counting
disk seeks. For small tables, you can usually find a row in one
disk seek (because the index is probably cached). For bigger
tables, you can estimate that, using B-tree indexes, you need
this many seeks to find a row:
log(
.
row_count
) /
log(index_block_length
/ 3 × 2
/ (index_length
+
data_pointer_length
)) + 1
In MySQL, an index block is usually 1,024 bytes and the data
pointer is usually four bytes. For a 500,000-row table with an
index length of three bytes (the size of
MEDIUMINT
), the formula indicates
log(500,000)/log(1024/3×2/(3+4)) + 1
=
4
seeks.
This index would require storage of about 500,000 × 7 × 3/2 = 5.2MB (assuming a typical index buffer fill ratio of 2/3), so you probably have much of the index in memory and so need only one or two calls to read data to find the row.
For writes, however, you need four seek requests to find where to place a new index value and normally two seeks to update the index and write the row.
Note that the preceding discussion does not mean that your
application performance slowly degenerates by log N. As long as
everything is cached by the OS or the MySQL server, things
become only marginally slower as the table gets bigger. After
the data gets too big to be cached, things start to go much
slower until your applications are only bound by disk-seeks
(which increase by log N
). To avoid
this, increase the key cache size as the data grows. For
MyISAM
tables, the key cache size is
controlled by the key_buffer_size
system
variable. See Section 7.5.2, “Tuning Server Parameters”.
MySQL Enterprise The MySQL Enterprise Monitor provides a number of advisors specifically designed to improve query performance. For more information see http://www.mysql.com/products/enterprise/advisors.html.
In general, when you want to make a slow SELECT ...
WHERE
query faster, the first thing to check is
whether you can add an index. All references between different
tables should usually be done with indexes. You can use the
EXPLAIN
statement to determine which indexes
are used for a SELECT
. See
Section 12.3.2, “EXPLAIN
Syntax”, and Section 7.4.5, “How MySQL Uses Indexes”.
Some general tips for speeding up queries on
MyISAM
tables:
To help MySQL better optimize queries, use ANALYZE
TABLE
or run myisamchk
--analyze on a table after it has been loaded with
data. This updates a value for each index part that
indicates the average number of rows that have the same
value. (For unique indexes, this is always 1.) MySQL uses
this to decide which index to choose when you join two
tables based on a non-constant expression. You can check the
result from the table analysis by using SHOW INDEX
FROM
and
examining the tbl_name
Cardinality
value.
myisamchk --description --verbose shows
index distribution information.
To sort an index and data according to an index, use myisamchk --sort-index --sort-records=1 (assuming that you want to sort on index 1). This is a good way to make queries faster if you have a unique index from which you want to read all rows in order according to the index. The first time you sort a large table this way, it may take a long time.
This section discusses optimizations that can be made for
processing WHERE
clauses. The examples use
SELECT
statements, but the same optimizations
apply for WHERE
clauses in
DELETE
and UPDATE
statements.
Work on the MySQL optimizer is ongoing, so this section is incomplete. MySQL performs a great many optimizations, not all of which are documented here.
Some of the optimizations performed by MySQL follow:
Removal of unnecessary parentheses:
((a AND b) AND c OR (((a AND b) AND (c AND d)))) -> (a AND b AND c) OR (a AND b AND c AND d)
Constant folding:
(a<b AND b=c) AND a=5 -> b>5 AND b=c AND a=5
Constant condition removal (needed because of constant folding):
(B>=5 AND B=5) OR (B=6 AND 5=5) OR (B=7 AND 5=6) -> B=5 OR B=6
Constant expressions used by indexes are evaluated only once.
COUNT(*)
on a single table
without a WHERE
is retrieved directly
from the table information for MyISAM
and
MEMORY
(HASH
) tables.
This is also done for any NOT NULL
expression when used with only one table.
Early detection of invalid constant expressions. MySQL
quickly detects that some SELECT
statements are impossible and returns no rows.
HAVING
is merged with
WHERE
if you do not use GROUP
BY
or aggregate functions
(COUNT()
,
MIN()
, and so on).
For each table in a join, a simpler WHERE
is constructed to get a fast WHERE
evaluation for the table and also to skip rows as soon as
possible.
All constant tables are read first before any other tables in the query. A constant table is any of the following:
An empty table or a table with one row.
A table that is used with a WHERE
clause on a PRIMARY KEY
or a
UNIQUE
index, where all index parts
are compared to constant expressions and are defined as
NOT NULL
.
All of the following tables are used as constant tables:
SELECT * FROM t WHEREprimary_key
=1; SELECT * FROM t1,t2 WHERE t1.primary_key
=1 AND t2.primary_key
=t1.id;
The best join combination for joining the tables is found by
trying all possibilities. If all columns in ORDER
BY
and GROUP BY
clauses come
from the same table, that table is preferred first when
joining.
If there is an ORDER BY
clause and a
different GROUP BY
clause, or if the
ORDER BY
or GROUP BY
contains columns from tables other than the first table in
the join queue, a temporary table is created.
If you use the SQL_SMALL_RESULT
option,
MySQL uses an in-memory temporary table.
Each table index is queried, and the best index is used unless the optimizer believes that it is more efficient to use a table scan. At one time, a scan was used based on whether the best index spanned more than 30% of the table, but a fixed percentage no longer determines the choice between using an index or a scan. The optimizer now is more complex and bases its estimate on additional factors such as table size, number of rows, and I/O block size.
In some cases, MySQL can read rows from the index without even consulting the data file. If all columns used from the index are numeric, only the index tree is used to resolve the query.
Before each row is output, those that do not match the
HAVING
clause are skipped.
Some examples of queries that are very fast:
SELECT COUNT(*) FROMtbl_name
; SELECT MIN(key_part1
),MAX(key_part1
) FROMtbl_name
; SELECT MAX(key_part2
) FROMtbl_name
WHEREkey_part1
=constant
; SELECT ... FROMtbl_name
ORDER BYkey_part1
,key_part2
,... LIMIT 10; SELECT ... FROMtbl_name
ORDER BYkey_part1
DESC,key_part2
DESC, ... LIMIT 10;
MySQL resolves the following queries using only the index tree, assuming that the indexed columns are numeric:
SELECTkey_part1
,key_part2
FROMtbl_name
WHEREkey_part1
=val
; SELECT COUNT(*) FROMtbl_name
WHEREkey_part1
=val1
ANDkey_part2
=val2
; SELECTkey_part2
FROMtbl_name
GROUP BYkey_part1
;
The following queries use indexing to retrieve the rows in sorted order without a separate sorting pass:
SELECT ... FROMtbl_name
ORDER BYkey_part1
,key_part2
,... ; SELECT ... FROMtbl_name
ORDER BYkey_part1
DESC,key_part2
DESC, ... ;
The range
access method uses a single index
to retrieve a subset of table rows that are contained within one
or several index value intervals. It can be used for a
single-part or multiple-part index. The following sections give
a detailed description of how intervals are extracted from the
WHERE
clause.
For a single-part index, index value intervals can be
conveniently represented by corresponding conditions in the
WHERE
clause, so we speak of
range conditions rather than
“intervals.”
The definition of a range condition for a single-part index is as follows:
For both BTREE
and
HASH
indexes, comparison of a key part
with a constant value is a range condition when using the
=
,
<=>
,
IN()
,
IS NULL
, or
IS NOT NULL
operators.
For BTREE
indexes, comparison of a key
part with a constant value is a range condition when using
the
>
,
<
,
>=
,
<=
,
BETWEEN
,
!=
,
or
<>
operators, or LIKE
comparisons if the argument to
LIKE
is a constant
string that does not start with a wildcard character.
For all types of indexes, multiple range conditions
combined with OR
or
AND
form a range
condition.
“Constant value” in the preceding descriptions means one of the following:
A constant from the query string
A column of a const
or
system
table from the same join
The result of an uncorrelated subquery
Any expression composed entirely from subexpressions of the preceding types
Here are some examples of queries with range conditions in the
WHERE
clause:
SELECT * FROM t1 WHEREkey_col
> 1 ANDkey_col
< 10; SELECT * FROM t1 WHEREkey_col
= 1 ORkey_col
IN (15,18,20); SELECT * FROM t1 WHEREkey_col
LIKE 'ab%' ORkey_col
BETWEEN 'bar' AND 'foo';
Note that some non-constant values may be converted to constants during the constant propagation phase.
MySQL tries to extract range conditions from the
WHERE
clause for each of the possible
indexes. During the extraction process, conditions that cannot
be used for constructing the range condition are dropped,
conditions that produce overlapping ranges are combined, and
conditions that produce empty ranges are removed.
Consider the following statement, where
key1
is an indexed column and
nonkey
is not indexed:
SELECT * FROM t1 WHERE (key1 < 'abc' AND (key1 LIKE 'abcde%' OR key1 LIKE '%b')) OR (key1 < 'bar' AND nonkey = 4) OR (key1 < 'uux' AND key1 > 'z');
The extraction process for key key1
is as
follows:
Start with original WHERE
clause:
(key1 < 'abc' AND (key1 LIKE 'abcde%' OR key1 LIKE '%b')) OR (key1 < 'bar' AND nonkey = 4) OR (key1 < 'uux' AND key1 > 'z')
Remove nonkey = 4
and key1
LIKE '%b'
because they cannot be used for a
range scan. The correct way to remove them is to replace
them with TRUE
, so that we do not miss
any matching rows when doing the range scan. Having
replaced them with TRUE
, we get:
(key1 < 'abc' AND (key1 LIKE 'abcde%' OR TRUE)) OR (key1 < 'bar' AND TRUE) OR (key1 < 'uux' AND key1 > 'z')
Collapse conditions that are always true or false:
(key1 LIKE 'abcde%' OR TRUE)
is
always true
(key1 < 'uux' AND key1 > 'z')
is always false
Replacing these conditions with constants, we get:
(key1 < 'abc' AND TRUE) OR (key1 < 'bar' AND TRUE) OR (FALSE)
Removing unnecessary TRUE
and
FALSE
constants, we obtain:
(key1 < 'abc') OR (key1 < 'bar')
Combining overlapping intervals into one yields the final condition to be used for the range scan:
(key1 < 'bar')
In general (and as demonstrated by the preceding example), the
condition used for a range scan is less restrictive than the
WHERE
clause. MySQL performs an additional
check to filter out rows that satisfy the range condition but
not the full WHERE
clause.
The range condition extraction algorithm can handle nested
AND
/OR
constructs of arbitrary depth, and its output does not depend
on the order in which conditions appear in
WHERE
clause.
Range conditions on a multiple-part index are an extension of range conditions for a single-part index. A range condition on a multiple-part index restricts index rows to lie within one or several key tuple intervals. Key tuple intervals are defined over a set of key tuples, using ordering from the index.
For example, consider a multiple-part index defined as
key1(
, and the
following set of key tuples listed in key order:
key_part1
,
key_part2
,
key_part3
)
key_part1
key_part2
key_part3
NULL 1 'abc' NULL 1 'xyz' NULL 2 'foo' 1 1 'abc' 1 1 'xyz' 1 2 'abc' 2 1 'aaa'
The condition
defines this interval:
key_part1
=
1
(1,-inf,-inf) <= (key_part1
,key_part2
,key_part3
) < (1,+inf,+inf)
The interval covers the 4th, 5th, and 6th tuples in the preceding data set and can be used by the range access method.
By contrast, the condition
does not define a single interval and cannot
be used by the range access method.
key_part3
=
'abc'
The following descriptions indicate how range conditions work for multiple-part indexes in greater detail.
For HASH
indexes, each interval
containing identical values can be used. This means that
the interval can be produced only for conditions in the
following form:
key_part1
cmp
const1
ANDkey_part2
cmp
const2
AND ... ANDkey_partN
cmp
constN
;
Here, const1
,
const2
, … are constants,
cmp
is one of the
=
,
<=>
,
or IS NULL
comparison
operators, and the conditions cover all index parts. (That
is, there are N
conditions, one
for each part of an N
-part
index.) For example, the following is a range condition
for a three-part HASH
index:
key_part1
= 1 ANDkey_part2
IS NULL ANDkey_part3
= 'foo'
For the definition of what is considered to be a constant, see Section 7.2.5.1, “The Range Access Method for Single-Part Indexes”.
For a BTREE
index, an interval might be
usable for conditions combined with
AND
, where each
condition compares a key part with a constant value using
=
,
<=>
,
IS NULL
,
>
,
<
,
>=
,
<=
,
!=
,
<>
,
BETWEEN
, or
LIKE
'
(where
pattern
''
does not start with a wildcard). An interval can be used
as long as it is possible to determine a single key tuple
containing all rows that match the condition (or two
intervals if
pattern
'<>
or
!=
is used). For example, for this condition:
key_part1
= 'foo' ANDkey_part2
>= 10 ANDkey_part3
> 10
The single interval is:
('foo',10,10) < (key_part1
,key_part2
,key_part3
) < ('foo',+inf,+inf)
It is possible that the created interval contains more
rows than the initial condition. For example, the
preceding interval includes the value ('foo', 11,
0)
, which does not satisfy the original
condition.
If conditions that cover sets of rows contained within
intervals are combined with
OR
, they form a
condition that covers a set of rows contained within the
union of their intervals. If the conditions are combined
with AND
, they form a
condition that covers a set of rows contained within the
intersection of their intervals. For example, for this
condition on a two-part index:
(key_part1
= 1 ANDkey_part2
< 2) OR (key_part1
> 5)
The intervals are:
(1,-inf) < (key_part1
,key_part2
) < (1,2) (5,-inf) < (key_part1
,key_part2
)
In this example, the interval on the first line uses one
key part for the left bound and two key parts for the
right bound. The interval on the second line uses only one
key part. The key_len
column in the
EXPLAIN
output indicates the maximum
length of the key prefix used.
In some cases, key_len
may indicate
that a key part was used, but that might be not what you
would expect. Suppose that
key_part1
and
key_part2
can be
NULL
. Then the
key_len
column displays two key part
lengths for the following condition:
key_part1
>= 1 ANDkey_part2
< 2
But, in fact, the condition is converted to this:
key_part1
>= 1 ANDkey_part2
IS NOT NULL
Section 7.2.5.1, “The Range Access Method for Single-Part Indexes”, describes how optimizations are performed to combine or eliminate intervals for range conditions on a single-part index. Analogous steps are performed for range conditions on multiple-part indexes.
IS NULL
Optimization
MySQL can perform the same optimization on
col_name
IS
NULL
that it can use for
col_name
=
constant_value
. For example, MySQL
can use indexes and ranges to search for NULL
with IS NULL
.
Examples:
SELECT * FROMtbl_name
WHEREkey_col
IS NULL; SELECT * FROMtbl_name
WHEREkey_col
<=> NULL; SELECT * FROMtbl_name
WHEREkey_col
=const1
ORkey_col
=const2
ORkey_col
IS NULL;
If a WHERE
clause includes a
col_name
IS
NULL
condition for a column that is declared as
NOT NULL
, that expression is optimized away.
This optimization does not occur in cases when the column might
produce NULL
anyway; for example, if it comes
from a table on the right side of a LEFT
JOIN
.
MySQL 4.1.1 and up can also optimize the combination
, a form
that is common in resolved subqueries.
col_name
=
expr
OR
col_name
IS NULLEXPLAIN
shows ref_or_null
when this optimization is used.
This optimization can handle one IS
NULL
for any key part.
Some examples of queries that are optimized, assuming that there
is an index on columns a
and
b
of table t2
:
SELECT * FROM t1 WHERE t1.a=expr
OR t1.a IS NULL;
SELECT * FROM t1, t2 WHERE t1.a=t2.a OR t2.a IS NULL;
SELECT * FROM t1, t2
WHERE (t1.a=t2.a OR t2.a IS NULL) AND t2.b=t1.b;
SELECT * FROM t1, t2
WHERE t1.a=t2.a AND (t2.b=t1.b OR t2.b IS NULL);
SELECT * FROM t1, t2
WHERE (t1.a=t2.a AND t2.a IS NULL AND ...)
OR (t1.a=t2.a AND t2.a IS NULL AND ...);
ref_or_null
works by first doing a read on
the reference key, and then a separate search for rows with a
NULL
key value.
Note that the optimization can handle only one
IS NULL
level. In the
following query, MySQL uses key lookups only on the expression
(t1.a=t2.a AND t2.a IS NULL)
and is not able
to use the key part on b
:
SELECT * FROM t1, t2 WHERE (t1.a=t2.a AND t2.a IS NULL) OR (t1.b=t2.b AND t2.b IS NULL);
MySQL implements a
as
follows:
A
LEFT
JOIN B
join_condition
Table B
is set to depend on table
A
and all tables on which
A
depends.
Table A
is set to depend on all
tables (except B
) that are used
in the LEFT JOIN
condition.
The LEFT JOIN
condition is used to decide
how to retrieve rows from table
B
. (In other words, any condition
in the WHERE
clause is not used.)
All standard join optimizations are performed, with the exception that a table is always read after all tables on which it depends. If there is a circular dependence, MySQL issues an error.
All standard WHERE
optimizations are
performed.
If there is a row in A
that
matches the WHERE
clause, but there is no
row in B
that matches the
ON
condition, an extra
B
row is generated with all
columns set to NULL
.
If you use LEFT JOIN
to find rows that do
not exist in some table and you have the following test:
in the col_name
IS
NULLWHERE
part, where
col_name
is a column that is
declared as NOT NULL
, MySQL stops
searching for more rows (for a particular key combination)
after it has found one row that matches the LEFT
JOIN
condition.
The implementation of RIGHT JOIN
is analogous
to that of LEFT JOIN
with the roles of the
tables reversed.
The join optimizer calculates the order in which tables should
be joined. The table read order forced by LEFT
JOIN
or STRAIGHT_JOIN
helps the
join optimizer do its work much more quickly, because there are
fewer table permutations to check. Note that this means that if
you do a query of the following type, MySQL does a full scan on
b
because the LEFT JOIN
forces it to be read before d
:
SELECT * FROM a JOIN b LEFT JOIN c ON (c.key=a.key) LEFT JOIN d ON (d.key=a.key) WHERE b.key=d.key;
The fix in this case is reverse the order in which
a
and b
are listed in the
FROM
clause:
SELECT * FROM b JOIN a LEFT JOIN c ON (c.key=a.key) LEFT JOIN d ON (d.key=a.key) WHERE b.key=d.key;
Starting from 4.0.14, for a LEFT JOIN
, if
the WHERE
condition is always false for the
generated NULL
row, the LEFT
JOIN
is changed to a normal join. For example, the
WHERE
clause would be false in the following
query if t2.column1
were
NULL
:
SELECT * FROM t1 LEFT JOIN t2 ON (column1) WHERE t2.column2=5;
Therefore, it is safe to convert the query to a normal join:
SELECT * FROM t1, t2 WHERE t2.column2=5 AND t1.column1=t2.column1;
This can be made faster because MySQL can use table
t2
before table t1
if
doing so would result in a better query plan. To force a
specific table order, use STRAIGHT_JOIN
.
In some cases, MySQL can use an index to satisfy an
ORDER BY
clause without doing any extra
sorting.
The index can also be used even if the ORDER
BY
does not match the index exactly, as long as all of
the unused portions of the index and all the extra
ORDER BY
columns are constants in the
WHERE
clause. The following queries use the
index to resolve the ORDER BY
part:
SELECT * FROM t1 ORDER BYkey_part1
,key_part2
,... ; SELECT * FROM t1 WHEREkey_part1
=constant
ORDER BYkey_part2
; SELECT * FROM t1 ORDER BYkey_part1
DESC,key_part2
DESC; SELECT * FROM t1 WHEREkey_part1
=1 ORDER BYkey_part1
DESC,key_part2
DESC;
In some cases, MySQL cannot use indexes to
resolve the ORDER BY
, although it still uses
indexes to find the rows that match the WHERE
clause. These cases include the following:
You use ORDER BY
on different keys:
SELECT * FROM t1 ORDER BYkey1
,key2
;
You use ORDER BY
on non-consecutive parts
of a key:
SELECT * FROM t1 WHEREkey2
=constant
ORDER BYkey_part2
;
You mix ASC
and DESC
:
SELECT * FROM t1 ORDER BYkey_part1
DESC,key_part2
ASC;
The key used to fetch the rows is not the same as the one
used in the ORDER BY
:
SELECT * FROM t1 WHEREkey2
=constant
ORDER BYkey1
;
You use ORDER BY
with an expression that
includes terms other than the key column name:
SELECT * FROM t1 ORDER BY ABS(key
); SELECT * FROM t1 ORDER BY -key
;
You are joining many tables, and the columns in the
ORDER BY
are not all from the first
non-constant table that is used to retrieve rows. (This is
the first table in the EXPLAIN
output
that does not have a const
join type.)
You have different ORDER BY
and
GROUP BY
expressions.
The type of table index used does not store rows in order.
For example, this is true for a HASH
index in a MEMORY
table.
Availability of an index for sorting may be affected by the use
of column aliases. Suppose that the column
t1.a
is indexed. In this statement, the name
of the column in the select list is a
. It
refers to t1.a
, so for the reference to
a
in the ORDER BY
, the
index can be used:
SELECT a FROM t1 ORDER BY a;
In this statement, the name of the column in the select list is
also a
, but it is the alias name. It refers
to ABS(a)
, so for the reference to
a
in the ORDER BY
, the
index cannot be used:
SELECT ABS(a) AS a FROM t1 ORDER BY a;
In the following statement, the ORDER BY
refers to a name that is not the name of a column in the select
list. But there is a column in t1
named
a
, so the ORDER BY
uses
that, and the index can be used. (The resulting sort order may
be completely different from the order for
ABS(a)
, of course.)
SELECT ABS(a) AS b FROM t1 ORDER BY a;
By default, MySQL sorts all GROUP BY
queries as if you
specified col1
,
col2
, ...ORDER BY
in the query as
well. If you include an col1
,
col2
, ...ORDER BY
clause
explicitly that contains the same column list, MySQL optimizes
it away without any speed penalty, although the sorting still
occurs. If a query includes GROUP BY
but you
want to avoid the overhead of sorting the result, you can
suppress sorting by specifying ORDER BY NULL
.
For example:
INSERT INTO foo SELECT a, COUNT(*) FROM bar GROUP BY a ORDER BY NULL;
With EXPLAIN SELECT ... ORDER BY
, you can
check whether MySQL can use indexes to resolve the query. It
cannot if you see Using filesort
in the
Extra
column. See Section 12.3.2, “EXPLAIN
Syntax”.
MySQL has two filesort
algorithms for sorting
and retrieving results. The original method uses only the
ORDER BY
columns. The modified method uses
not just the ORDER BY
columns, but all the
columns used in the query.
The optimizer selects which filesort
algorithm to use. Prior to MySQL 4.1, it uses the original
algorithm. As of MySQL 4.1, it normally uses the modified
algorithm except when BLOB
or
TEXT
columns are involved, in which case it
uses the original algorithm.
The original filesort
algorithm works as
follows:
Read all rows according to key or by table scanning. Rows
that do not match the WHERE
clause are
skipped.
For each row, store a pair of values in a buffer (the sort
key and the row pointer). The size of the buffer is the
value of the sort_buffer_size
system
variable.
When the buffer gets full, run a qsort (quicksort) on it and store the result in a temporary file. Save a pointer to the sorted block. (If all pairs fit into the sort buffer, no temporary file is created.)
Repeat the preceding steps until all rows have been read.
Do a multi-merge of up to MERGEBUFF
(7)
regions to one block in another temporary file. Repeat until
all blocks from the first file are in the second file.
Repeat the following until there are fewer than
MERGEBUFF2
(15) blocks left.
On the last multi-merge, only the pointer to the row (the last part of the sort key) is written to a result file.
Read the rows in sorted order by using the row pointers in
the result file. To optimize this, we read in a big block of
row pointers, sort them, and use them to read the rows in
sorted order into a row buffer. The size of the buffer is
the value of the read_rnd_buffer_size
system variable. The code for this step is in the
sql/records.cc
source file.
One problem with this approach is that it reads rows twice: One
time when evaluating the WHERE
clause, and
again after sorting the pair values. And even if the rows were
accessed successively the first time (for example, if a table
scan is done), the second time they are accessed randomly. (The
sort keys are ordered, but the row positions are not.)
The modified filesort
algorithm incorporates
an optimization such that it records not only the sort key value
and row position, but also the columns required for the query.
This avoids reading the rows twice. The modified
filesort
algorithm works like this:
Read the rows that match the WHERE
clause.
For each row, record a tuple of values consisting of the sort key value and row position, and also the columns required for the query.
Sort the tuples by sort key value
Retrieve the rows in sorted order, but read the required columns directly from the sorted tuples rather than by accessing the table a second time.
Using the modified filesort
algorithm, the
tuples are longer than the pairs used in the original method,
and fewer of them fit in the sort buffer (the size of which is
given by sort_buffer_size
). As a result, it
is possible for the extra I/O to make the modified approach
slower, not faster. To avoid a slowdown, the optimization is
used only if the total size of the extra columns in the sort
tuple does not exceed the value of the
max_length_for_sort_data
system variable. (A
symptom of setting the value of this variable too high is that
you should see high disk activity and low CPU activity.)
For slow queries for which filesort
is not
used, you might try lowering
max_length_for_sort_data
to a value that is
appropriate to trigger a filesort
.
If you want to increase ORDER BY
speed, check
whether you can get MySQL to use indexes rather than an extra
sorting phase. If this is not possible, you can try the
following strategies:
Increase the size of the sort_buffer_size
variable.
Increase the size of the
read_rnd_buffer_size
variable.
Use less RAM per row by declaring columns only as large as
they need to be to hold the values stored in them. For
example, CHAR(16)
is better than
CHAR(200)
if values never exceed 16
characters.
Change tmpdir
to point to a dedicated
filesystem with large amounts of free space. Also, if you
use MySQL 4.1 or later, this option accepts several paths
that are used in round-robin fashion, so you you can use
this feature to spread the load across several directories.
Paths should be separated by colon characters
(“:
”) on Unix and semicolon
characters (“;
”) on Windows,
NetWare, and OS/2. The paths should be for directories in
filesystems that are located on different
physical disks, not different
partitions on the same disk.
The most general way to satisfy a GROUP BY
clause is to scan the whole table and create a new temporary
table where all rows from each group are consecutive, and then
use this temporary table to discover groups and apply aggregate
functions (if any). In some cases, MySQL is able to do much
better than that and to avoid creation of temporary tables by
using index access.
The most important preconditions for using indexes for
GROUP BY
are that all GROUP
BY
columns reference attributes from the same index,
and that the index stores its keys in order (for example, this
is a BTREE
index, and not a
HASH
index). Whether use of temporary tables
can be replaced by index access also depends on which parts of
an index are used in a query, the conditions specified for these
parts, and the selected aggregate functions.
In MySQL, GROUP BY
is used for sorting, so
the server may also apply ORDER BY
optimizations to grouping. See
Section 7.2.8, “ORDER BY
Optimization”.
There are two ways to execute a GROUP BY
query via index access, as detailed in the following sections.
In the first method, the grouping operation is applied together
with all range predicates (if any). The second method first
performs a range scan, and then groups the resulting tuples.
A tight index scan may be either a full index scan or a range index scan, depending on the query conditions.
When the conditions for a loose index scan are not met, it is
still possible to avoid creation of temporary tables for
GROUP BY
queries. If there are range
conditions in the WHERE
clause, this method
reads only the keys that satisfy these conditions. Otherwise,
it performs an index scan. Because this method reads all keys
in each range defined by the WHERE
clause,
or scans the whole index if there are no range conditions, we
term it a tight index scan. Notice that
with a tight index scan, the grouping operation is performed
only after all keys that satisfy the range conditions have
been found.
For this method to work, it is sufficient that there is a
constant equality condition for all columns in a query
referring to parts of the key coming before or in between
parts of the GROUP BY
key. The constants
from the equality conditions fill in any “gaps”
in the search keys so that it is possible to form complete
prefixes of the index. These index prefixes then can be used
for index lookups. If we require sorting of the GROUP
BY
result, and it is possible to form search keys
that are prefixes of the index, MySQL also avoids extra
sorting operations because searching with prefixes in an
ordered index already retrieves all the keys in order.
The following queries do not work with the loose index scan
access method described earlier, but still work with the tight
index scan access method (assuming that there is an index
idx(c1,c2,c3)
on table
t1(c1,c2,c3,c4)
).
There is a gap in the GROUP BY
, but it
is covered by the condition c2 = 'a'
:
SELECT c1, c2, c3 FROM t1 WHERE c2 = 'a' GROUP BY c1, c3;
The GROUP BY
does not begin with the
first part of the key, but there is a condition that
provides a constant for that part:
SELECT c1, c2, c3 FROM t1 WHERE c1 = 'a' GROUP BY c2, c3;
DISTINCT
combined with ORDER
BY
needs a temporary table in many cases.
Because DISTINCT
may use GROUP
BY
, you should be aware of how MySQL works with
columns in ORDER BY
or
HAVING
clauses that are not part of the
selected columns. See Section 11.11.3, “GROUP BY
and HAVING
with Hidden
Fields”.
In most cases, a DISTINCT
clause can be
considered as a special case of GROUP BY
. For
example, the following two queries are equivalent:
SELECT DISTINCT c1, c2, c3 FROM t1 WHERE c1 >const
; SELECT c1, c2, c3 FROM t1 WHERE c1 >const
GROUP BY c1, c2, c3;
Due to this equivalence, the optimizations applicable to
GROUP BY
queries can be also applied to
queries with a DISTINCT
clause. Thus, for
more details on the optimization possibilities for
DISTINCT
queries, see
Section 7.2.9, “GROUP BY
Optimization”.
When combining LIMIT
with
row_count
DISTINCT
, MySQL stops as soon as it finds
row_count
unique rows.
If you do not use columns from all tables named in a query,
MySQL stops scanning any unused tables as soon as it finds the
first match. In the following case, assuming that
t1
is used before t2
(which you can check with EXPLAIN
), MySQL
stops reading from t2
(for any particular row
in t1
) when it finds the first row in
t2
:
SELECT DISTINCT t1.a FROM t1, t2 where t1.a=t2.a;
In some cases, MySQL handles a query differently when you are
using LIMIT
and not using
row_count
HAVING
:
If you are selecting only a few rows with
LIMIT
, MySQL uses indexes in some cases
when normally it would prefer to do a full table scan.
If you use LIMIT
with
row_count
ORDER BY
, MySQL ends the sorting as soon
as it has found the first
row_count
rows of the sorted
result, rather than sorting the entire result. If ordering
is done by using an index, this is very fast. If a filesort
must be done, all rows that match the query without the
LIMIT
clause must be selected, and most
or all of them must be sorted, before it can be ascertained
that the first row_count
rows
have been found. In either case, after the initial rows have
been found, there is no need to sort any remainder of the
result set, and MySQL does not do so.
When combining LIMIT
with
row_count
DISTINCT
, MySQL stops as soon as it finds
row_count
unique rows.
In some cases, a GROUP BY
can be resolved
by reading the key in order (or doing a sort on the key) and
then calculating summaries until the key value changes. In
this case, LIMIT
does not
calculate any unnecessary row_count
GROUP BY
values.
As soon as MySQL has sent the required number of rows to the
client, it aborts the query unless you are using
SQL_CALC_FOUND_ROWS
.
LIMIT 0
quickly returns an empty set.
This can be useful for checking the validity of a query.
When using one of the MySQL APIs, it can also be employed
for obtaining the types of the result columns. (This trick
does not work in the MySQL Monitor (the
mysql program), which merely displays
Empty set
in such cases; you should
instead use SHOW COLUMNS
or
DESCRIBE
for this purpose.)
When the server uses temporary tables to resolve the query,
it uses the LIMIT
clause to
calculate how much space is required.
row_count
The output from EXPLAIN
shows
ALL
in the type
column
when MySQL uses a table scan to resolve a query. This usually
happens under the following conditions:
The table is so small that it is faster to perform a table scan than to bother with a key lookup. This is common for tables with fewer than 10 rows and a short row length.
There are no usable restrictions in the
ON
or WHERE
clause for
indexed columns.
You are comparing indexed columns with constant values and
MySQL has calculated (based on the index tree) that the
constants cover too large a part of the table and that a
table scan would be faster. See
Section 7.2.4, “WHERE
Clause Optimization”.
You are using a key with low cardinality (many rows match the key value) through another column. In this case, MySQL assumes that by using the key it probably will do many key lookups and that a table scan would be faster.
MySQL Enterprise For expert advice on avoiding excessive table scans subscribe to the MySQL Enterprise Monitor. For more information see http://www.mysql.com/products/enterprise/advisors.html.
For small tables, a table scan often is appropriate and the performance impact is negligible. For large tables, try the following techniques to avoid having the optimizer incorrectly choose a table scan:
Use ANALYZE TABLE
to update the
key distributions for the scanned table. See
Section 12.5.2.1, “tbl_name
ANALYZE TABLE
Syntax”.
Use FORCE INDEX
for the scanned table to
tell MySQL that table scans are very expensive compared to
using the given index:
SELECT * FROM t1, t2 FORCE INDEX (index_for_column
) WHERE t1.col_name
=t2.col_name
;
Start mysqld with the
--max-seeks-for-key=1000
option or use
SET max_seeks_for_key=1000
to tell the
optimizer to assume that no key scan causes more than 1,000
key seeks. See Section 5.1.3, “System Variables”.
The time required for inserting a row is determined by the following factors, where the numbers indicate approximate proportions:
Connecting: (3)
Sending query to server: (2)
Parsing query: (2)
Inserting row: (1 × size of row)
Inserting indexes: (1 × number of indexes)
Closing: (1)
This does not take into consideration the initial overhead to open tables, which is done once for each concurrently running query.
The size of the table slows down the insertion of indexes by log
N
, assuming B-tree indexes.
You can use the following methods to speed up inserts:
If you are inserting many rows from the same client at the
same time, use INSERT
statements with
multiple VALUES
lists to insert several
rows at a time. This is considerably faster (many times
faster in some cases) than using separate single-row
INSERT
statements. If you are adding data
to a non-empty table, you can tune the
bulk_insert_buffer_size
variable to make
data insertion even faster. See
Section 5.1.3, “System Variables”.
If multiple clients are inserting a lot of rows, you can get
higher speed by using the INSERT DELAYED
statement. See Section 12.2.4.2, “INSERT DELAYED
Syntax”.
For a MyISAM
table, you can use
concurrent inserts to add rows at the same time that
SELECT
statements are running, if there
are no deleted rows in middle of the data file. See
Section 7.3.3, “Concurrent Inserts”.
When loading a table from a text file, use LOAD
DATA INFILE
. This is usually 20 times faster than
using INSERT
statements. See
Section 12.2.5, “LOAD DATA INFILE
Syntax”.
With some extra work, it is possible to make LOAD
DATA INFILE
run even faster for a
MyISAM
table when the table has many
indexes. Use the following procedure:
Optionally create the table with CREATE
TABLE
.
Execute a FLUSH TABLES
statement or a
mysqladmin flush-tables command.
Use myisamchk --keys-used=0 -rq
/path/to/db/tbl_name
.
This removes all use of indexes for the table.
Insert data into the table with LOAD DATA
INFILE
. This does not update any indexes and
therefore is very fast.
If you intend only to read from the table in the future, use myisampack to compress it. See Section 13.1.3.3, “Compressed Table Characteristics”.
Re-create the indexes with myisamchk -rq
/path/to/db/tbl_name
.
This creates the index tree in memory before writing it
to disk, which is much faster that updating the index
during LOAD DATA INFILE
because it
avoids lots of disk seeks. The resulting index tree is
also perfectly balanced.
Execute a FLUSH TABLES
statement or a
mysqladmin flush-tables command.
LOAD DATA INFILE
performs the preceding
optimization automatically if the MyISAM
table into which you insert data is empty. The main
difference between automatic optimization and using the
procedure explicitly is that you can let
myisamchk allocate much more temporary
memory for the index creation than you might want the server
to allocate for index re-creation when it executes the
LOAD DATA INFILE
statement.
As of MySQL 4.0, you can also disable or enable the indexes
for a MyISAM
table by using the following
statements rather than myisamchk. If you
use these statements, you can skip the FLUSH
TABLE
operations:
ALTER TABLEtbl_name
DISABLE KEYS; ALTER TABLEtbl_name
ENABLE KEYS;
To speed up INSERT
operations that are
performed with multiple statements for non-transactional
tables, lock your tables:
LOCK TABLES a WRITE; INSERT INTO a VALUES (1,23),(2,34),(4,33); INSERT INTO a VALUES (8,26),(6,29); ... UNLOCK TABLES;
This benefits performance because the index buffer is
flushed to disk only once, after all
INSERT
statements have completed.
Normally, there would be as many index buffer flushes as
there are INSERT
statements. Explicit
locking statements are not needed if you can insert all rows
with a single INSERT
.
To obtain faster insertions for transactional tables, you
should use START TRANSACTION
and
COMMIT
instead of LOCK
TABLES
.
Locking also lowers the total time for multiple-connection tests, although the maximum wait time for individual connections might go up because they wait for locks. Suppose that five clients attempt to perform inserts simultaneously as follows:
Connection 1 does 1000 inserts
Connections 2, 3, and 4 do 1 insert
Connection 5 does 1000 inserts
If you do not use locking, connections 2, 3, and 4 finish before 1 and 5. If you use locking, connections 2, 3, and 4 probably do not finish before 1 or 5, but the total time should be about 40% faster.
INSERT
, UPDATE
, and
DELETE
operations are very fast in MySQL,
but you can obtain better overall performance by adding
locks around everything that does more than about five
successive inserts or updates. If you do very many
successive inserts, you could do a LOCK
TABLES
followed by an UNLOCK
TABLES
once in a while (each 1,000 rows or so) to
allow other threads access to the table. This would still
result in a nice performance gain.
INSERT
is still much slower for loading
data than LOAD DATA INFILE
, even when
using the strategies just outlined.
To increase performance for MyISAM
tables, for both LOAD DATA INFILE
and
INSERT
, enlarge the key cache by
increasing the key_buffer_size
system
variable. See Section 7.5.2, “Tuning Server Parameters”.
MySQL Enterprise For more advice on optimizing the performance of your server, subscribe to the MySQL Enterprise Monitor. Numerous advisors are dedicated to monitoring performance. For more information see, http://www.mysql.com/products/enterprise/advisors.html.
An update statement is optimized like a
SELECT
query with the additional overhead of
a write. The speed of the write depends on the amount of data
being updated and the number of indexes that are updated.
Indexes that are not changed do not get updated.
Another way to get fast updates is to delay updates and then do many updates in a row later. Performing multiple updates together is much quicker than doing one at a time if you lock the table.
For a MyISAM
table that uses dynamic row
format, updating a row to a longer total length may split the
row. If you do this often, it is very important to use
OPTIMIZE TABLE
occasionally. See
Section 12.5.2.5, “OPTIMIZE TABLE
Syntax”.
The time required to delete individual rows is exactly
proportional to the number of indexes. To delete rows more
quickly, you can increase the size of the key cache by
increasing the key_buffer_size
system
variable. See Section 7.5.2, “Tuning Server Parameters”.
To delete all rows from a table, TRUNCATE TABLE
is faster than
than tbl_name
DELETE FROM Truncate operations are not
transaction-safe; an error occurs when attempting one in the
course of an active transaction or active table lock.
. See
Section 12.2.9, “tbl_name
TRUNCATE
Syntax”.
This section lists a number of miscellaneous tips for improving query processing speed:
Use persistent connections to the database to avoid
connection overhead. If you cannot use persistent
connections and you are initiating many new connections to
the database, you may want to change the value of the
thread_cache_size
variable. See
Section 7.5.2, “Tuning Server Parameters”.
Always check whether all your queries really use the indexes
that you have created in the tables. In MySQL, you can do
this with the EXPLAIN
statement. See
Section 12.3.2, “EXPLAIN
Syntax”.
Try to avoid complex SELECT
queries on
MyISAM
tables that are updated
frequently, to avoid problems with table locking that occur
due to contention between readers and writers.
MyISAM
supports concurrent inserts: If a
table has no free blocks in the middle of the data file, you
can INSERT
new rows into it at the same
time that other threads are reading from the table. If it is
important to be able to do this, you should consider using
the table in ways that avoid deleting rows. Another
possibility is to run OPTIMIZE TABLE
to
defragment the table after you have deleted a lot of rows
from it. See Section 7.3.3, “Concurrent Inserts”.
MySQL Enterprise For optimization tips geared to your specific circumstances subscribe to the MySQL Enterprise Monitor. For more information see http://www.mysql.com/products/enterprise/advisors.html.
To fix any compression issues that may have occurred with
ARCHIVE
tables, you can use
OPTIMIZE TABLE
. See
Section 13.7, “The ARCHIVE
Storage Engine”.
Use ALTER TABLE ... ORDER BY
if you
usually retrieve rows in
expr1
,
expr2
, ...
order. By
using this option after extensive changes to the table, you
may be able to get higher performance.
expr1
,
expr2
, ...
In some cases, it may make sense to introduce a column that is “hashed” based on information from other columns. If this column is short, reasonably unique, and indexed, it may be much faster than a “wide” index on many columns. In MySQL, it is very easy to use this extra column:
SELECT * FROMtbl_name
WHEREhash_col
=MD5(CONCAT(col1
,col2
)) ANDcol1
='constant
' ANDcol2
='constant
';
For MyISAM
tables that change frequently,
you should try to avoid all variable-length columns
(VARCHAR
, BLOB
, and
TEXT
). The table uses dynamic row format
if it includes even a single variable-length column. See
Chapter 13, Storage Engines.
It is normally not useful to split a table into different
tables just because the rows become large. In accessing a
row, the biggest performance hit is the disk seek needed to
find the first byte of the row. After finding the data, most
modern disks can read the entire row fast enough for most
applications. The only cases where splitting up a table
makes an appreciable difference is if it is a
MyISAM
table using dynamic row format
that you can change to a fixed row size, or if you very
often need to scan the table but do not need most of the
columns. See Chapter 13, Storage Engines.
If you often need to calculate results such as counts based on information from a lot of rows, it may be preferable to introduce a new table and update the counter in real time. An update of the following form is very fast:
UPDATEtbl_name
SETcount_col
=count_col
+1 WHEREkey_col
=constant
;
This is very important when you use MySQL storage engines
such as MyISAM
and
ISAM
that have only table-level locking
(multiple readers with single writers). This also gives
better performance with most database systems, because the
row locking manager in this case has less to do.
If you need to collect statistics from large log tables, use summary tables instead of scanning the entire log table. Maintaining the summaries should be much faster than trying to calculate statistics “live.” Regenerating new summary tables from the logs when things change (depending on business decisions) is faster than changing the running application.
If possible, you should classify reports as “live” or as “statistical,” where data needed for statistical reports is created only from summary tables that are generated periodically from the live data.
Take advantage of the fact that columns have default values. Insert values explicitly only when the value to be inserted differs from the default. This reduces the parsing that MySQL must do and improves the insert speed.
In some cases, it is convenient to pack and store data into
a BLOB
column. In this case, you must
provide code in your application to pack and unpack
information, but this may save a lot of accesses at some
stage. This is practical when you have data that does not
conform well to a rows-and-columns table structure.
Normally, you should try to keep all data non-redundant (observing what is referred to in database theory as third normal form). However, there may be situations in which it can be advantageous to duplicate information or create summary tables to gain more speed.
UDFs (user-defined functions) may be a good way to get more performance for some tasks. See Section 19.2, “Adding New Functions to MySQL”, for more information.
You can increase performance by caching queries or answers in your application and then executing many inserts or updates together. If your database system supports table locks, this should help to ensure that the index cache is only flushed once after all updates. You can also take advantage of MySQL's query cache to achieve similar results; see Section 7.5.3, “The MySQL Query Cache”.
Use INSERT DELAYED
when you do not need
to know when your data is written. This reduces the overall
insertion impact because many rows can be written with a
single disk write.
Use INSERT LOW_PRIORITY
when you want to
give SELECT
statements higher priority
than your inserts.
Use SELECT HIGH_PRIORITY
to get
retrievals that jump the queue. That is, the
SELECT
is executed even if there is
another client waiting to do a write.
LOW_PRIORITY
and
HIGH_PRIORITY
have an effect only for
storage engines that use only table-level locking
(MyISAM
, MEMORY
,
MERGE
).
Use multiple-row INSERT
statements to
store many rows with one SQL statement. Many SQL servers
support this, including MySQL.
Use LOAD DATA INFILE
to load large
amounts of data. This is faster than using
INSERT
statements.
Use AUTO_INCREMENT
columns so that each
row in a table can be identified by a single unique value.
unique values.
Use OPTIMIZE TABLE
once in a while to
avoid fragmentation with dynamic-format
MyISAM
tables. See
Section 13.1.3, “MyISAM
Table Storage Formats”.
Use MEMORY
(HEAP
)
tables when possible to get more speed. See
Section 13.4, “The MEMORY
(HEAP
) Storage Engine”.
MEMORY
tables are useful for non-critical
data that is accessed often, such as information about the
last displayed banner for users who don't have cookies
enabled in their Web browser. User sessions are another
alternative available in many Web application environments
for handling volatile state data.
With Web servers, images and other binary assets should normally be stored as files. That is, store only a reference to the file rather than the file itself in the database. Most Web servers are better at caching files than database contents, so using files is generally faster.
Columns with identical information in different tables should be declared to have identical data types so that joins based on the corresponding columns will be faster. Before MySQL 3.23, you get slow joins otherwise.
Try to keep column names simple. For example, in a table
named customer
, use a column name of
name
instead of
customer_name
. To make your names
portable to other SQL servers, you should keep them shorter
than 18 characters.
If you need really high speed, you should take a look at the
low-level interfaces for data storage that the different SQL
servers support. For example, by accessing the MySQL
MyISAM
storage engine directly, you could
get a speed increase of two to five times compared to using
the SQL interface. To be able to do this, the data must be
on the same server as the application, and usually it should
only be accessed by one process (because external file
locking is really slow). One could eliminate these problems
by introducing low-level MyISAM
commands
in the MySQL server (this could be one easy way to get more
performance if needed). By carefully designing the database
interface, it should be quite easy to support this type of
optimization.
If you are using numerical data, it is faster in many cases to access information from a database (using a live connection) than to access a text file. Information in the database is likely to be stored in a more compact format than in the text file, so accessing it involves fewer disk accesses. You also save code in your application because you need not parse your text files to find line and column boundaries.
Replication can provide a performance benefit for some operations. You can distribute client retrievals among replication servers to split up the load. To avoid slowing down the master while making backups, you can make backups using a slave server. See Chapter 6, Replication.
Declaring a MyISAM
table with the
DELAY_KEY_WRITE=1
table option makes
index updates faster because they are not flushed to disk
until the table is closed. The downside is that if something
kills the server while such a table is open, you should
ensure that the table is okay by running the server with the
--myisam-recover
option, or by running
myisamchk before restarting the server.
(However, even in this case, you should not lose anything by
using DELAY_KEY_WRITE
, because the key
information can always be generated from the data rows.)
MySQL manages contention for table contents using locking:
Internal locking is performed within the MySQL server itself to manage contention for table contents by multiple threads. This type of locking is internal because it is performed entirely by the server and involves no other programs. See Section 7.3.1, “Internal Locking Methods”.
External locking occurs when the server and other programs lock table files to coordinate among themselves which program can access the tables at which time. See Section 7.3.4, “External Locking”. See Section 7.3.4, “External Locking”.
This section discusses internal locking; that is, locking performed within the MySQL server itself to manage contention for table contents by multiple threads. This type of locking is internal because it is performed entirely by the server and involves no other programs. External locking occurs when the server and other programs lock table files to coordinate among themselves which program can access the tables at which time. See Section 7.3.4, “External Locking”.
MySQL uses table-level locking for ISAM
,
MyISAM
, and MEMORY
(HEAP
) tables, page-level locking for
BDB
tables, and row-level locking for
InnoDB
tables.
In many cases, you can make an educated guess about which locking type is best for an application, but generally it is difficult to say that a given lock type is better than another. Everything depends on the application and different parts of an application may require different lock types.
To decide whether you want to use a storage engine with
row-level locking, you should look at what your application does
and what mix of select and update statements it uses. For
example, most Web applications perform many selects, relatively
few deletes, updates based mainly on key values, and inserts
into a few specific tables. The base MySQL
MyISAM
setup is very well tuned for this.
MySQL Enterprise The MySQL Enterprise Monitor provides expert advice on when to use table-level locking and when to use row-level locking. To subscribe see http://www.mysql.com/products/enterprise/advisors.html.
Table locking in MySQL is deadlock-free for storage engines that use table-level locking. Deadlock avoidance is managed by always requesting all needed locks at once at the beginning of a query and always locking the tables in the same order.
MySQL grants table WRITE
locks as follows:
If there are no locks on the table, put a write lock on it.
Otherwise, put the lock request in the write lock queue.
MySQL grants table READ
locks as follows:
If there are no write locks on the table, put a read lock on it.
Otherwise, put the lock request in the read lock queue.
When a lock is released, the lock is made available to the
threads in the write lock queue and then to the threads in the
read lock queue. This means that if you have many updates for a
table, SELECT
statements wait until there are
no more updates.
Starting in MySQL 3.23.33, you can analyze the table lock
contention on your system by checking the
Table_locks_waited
and
Table_locks_immediate
status variables:
mysql> SHOW STATUS LIKE 'Table%';
+-----------------------+---------+
| Variable_name | Value |
+-----------------------+---------+
| Table_locks_immediate | 1151552 |
| Table_locks_waited | 15324 |
+-----------------------+---------+
As of MySQL 3.23.7 (3.23.25 for Windows), the
MyISAM
storage engine supports concurrent
inserts to reduce contention between readers and writers for a
given table: If a MyISAM
table has no free
blocks in the middle of the data file, rows are always inserted
at the end of the data file. In this case, you can freely mix
concurrent INSERT
and
SELECT
statements for a
MyISAM
table without locks. That is, you can
insert rows into a MyISAM
table at the same
time other clients are reading from it. (Holes can result from
rows having been deleted from or updated in the middle of the
table. If there are holes, concurrent inserts are disabled but
are re-enabled automatically when all holes have been filled
with new data.)
If you want to perform many INSERT
and
SELECT
operations on a table
real_table
when concurrent inserts are not
possible, you can insert rows into a temporary table
temp_table
and update the real table with the
rows from the temporary table periodically. This can be done
with the following code:
mysql>LOCK TABLES real_table WRITE, temp_table WRITE;
mysql>INSERT INTO real_table SELECT * FROM temp_table;
mysql>DELETE FROM temp_table;
mysql>UNLOCK TABLES;
InnoDB
uses row locks and
BDB
uses page locks. Deadlocks are possible
for these storage engines because they automatically acquire
locks during the processing of SQL statements, not at the start
of the transaction.
Advantages of row-level locking:
Fewer lock conflicts when accessing different rows in many threads
Fewer changes for rollbacks
Possible to lock a single row for a long time
Disadvantages of row-level locking:
Requires more memory than page-level or table-level locks
Slower than page-level or table-level locks when used on a large part of the table because you must acquire many more locks
Definitely much slower than other locks if you often do
GROUP BY
operations on a large part of
the data or if you must scan the entire table frequently
Table locks are superior to page-level or row-level locks in the following cases:
Most statements for the table are reads
Statements for the table are a mix of reads and writes, where writes are updates or deletes for a single row that can be fetched with one key read:
UPDATEtbl_name
SETcolumn
=value
WHEREunique_key_col
=key_value
; DELETE FROMtbl_name
WHEREunique_key_col
=key_value
;
SELECT
combined with concurrent
INSERT
statements, and very few
UPDATE
or DELETE
statements
Many scans or GROUP BY
operations on the
entire table without any writers
With higher-level locks, you can more easily tune applications by supporting locks of different types, because the lock overhead is less than for row-level locks.
Options other than row-level or page-level locking:
Versioning (such as that used in MySQL for concurrent inserts) where it is possible to have one writer at the same time as many readers. This means that the database or table supports different views for the data depending on when access begins. Other common terms for this are “time travel,” “copy on write,” or “copy on demand.”
Copy on demand is in many cases superior to page-level or row-level locking. However, in the worst case, it can use much more memory than using normal locks.
Instead of using row-level locks, you can employ
application-level locks, such as those provided by
GET_LOCK()
and
RELEASE_LOCK()
in MySQL.
These are advisory locks, so they work only in well-behaved
applications. See Section 11.10.4, “Miscellaneous Functions”.
To achieve a very high lock speed, MySQL uses table locking
(instead of page, row, or column locking) for all storage
engines except InnoDB
,
BDB
, and NDBCLUSTER
.
For InnoDB
and BDB
tables,
MySQL only uses table locking if you explicitly lock the table
with LOCK TABLES
. For these storage engines,
we recommend that you not use LOCK TABLES
at
all, because InnoDB
uses automatic row-level
locking and BDB
uses page-level locking to
ensure transaction isolation.
For large tables, table locking is much better than row locking for most applications, but there are some pitfalls:
Table locking enables many threads to read from a table at the same time, but if a thread wants to write to a table, it must first get exclusive access. During the update, all other threads that want to access this particular table must wait until the update is done.
Table updates normally are considered to be more important
than table retrievals, so they are given higher priority.
This should ensure that updates to a table are not
“starved” even if there is heavy
SELECT
activity for the table.
Table locking causes problems in cases such as when a thread is waiting because the disk is full and free space needs to become available before the thread can proceed. In this case, all threads that want to access the problem table are also put in a waiting state until more disk space is made available.
Table locking is also disadvantageous under the following scenario:
A client issues a SELECT
that takes a
long time to run.
Another client then issues an UPDATE
on
the same table. This client waits until the
SELECT
is finished.
Another client issues another SELECT
statement on the same table. Because
UPDATE
has higher priority than
SELECT
, this SELECT
waits for the UPDATE
to finish,
and for the first
SELECT
to finish.
The following items describe some ways to avoid or reduce contention caused by table locking:
Try to get the SELECT
statements to run
faster so that they lock tables for a shorter time. You
might have to create some summary tables to do this.
Start mysqld with
--low-priority-updates
. For storage engines
that use only table-level locking
(MyISAM
, MEMORY
,
MERGE
), this gives all statements that
update (modify) a table lower priority than
SELECT
statements. In this case, the
second SELECT
statement in the preceding
scenario would execute before the UPDATE
statement, and would not need to wait for the first
SELECT
to finish.
You can specify that all updates issued in a specific
connection should be done with low priority by using the
SET LOW_PRIORITY_UPDATES=1
statement. See
Section 12.5.3, “SET
Syntax”.
You can give a specific INSERT
,
UPDATE
, or DELETE
statement lower priority with the
LOW_PRIORITY
attribute.
You can give a specific SELECT
statement
higher priority with the HIGH_PRIORITY
attribute. See Section 12.2.7, “SELECT
Syntax”.
Starting from MySQL 3.23.7, you can start
mysqld with a low value for the
max_write_lock_count
system variable to
force MySQL to temporarily elevate the priority of all
SELECT
statements that are waiting for a
table after a specific number of inserts to the table occur.
This allows READ
locks after a certain
number of WRITE
locks.
If you have problems with INSERT
combined
with SELECT
, you might want to consider
switching to MyISAM
tables, which support
concurrent SELECT
and
INSERT
statements. (See
Section 7.3.3, “Concurrent Inserts”.)
If you mix inserts and deletes on the same table,
INSERT DELAYED
may be of great help. See
Section 12.2.4.2, “INSERT DELAYED
Syntax”.
If you have problems with mixed SELECT
and DELETE
statements, the
LIMIT
option to DELETE
may help. See Section 12.2.1, “DELETE
Syntax”.
Using SQL_BUFFER_RESULT
with
SELECT
statements can help to make the
duration of table locks shorter. See
Section 12.2.7, “SELECT
Syntax”.
You could change the locking code in
mysys/thr_lock.c
to use a single queue.
In this case, write locks and read locks would have the same
priority, which might help some applications.
Here are some tips concerning table locks in MySQL:
Concurrent users are not a problem if you do not mix updates with selects that need to examine many rows in the same table.
You can use LOCK TABLES
to increase
speed, because many updates within a single lock is much
faster than updating without locks. Splitting table contents
into separate tables may also help.
If you encounter speed problems with table locks in MySQL,
you may be able to improve performance by converting some of
your tables to InnoDB
or
BDB
tables. See Section 13.2, “The InnoDB
Storage Engine”,
and Section 13.5, “The BDB
(BerkeleyDB
) Storage
Engine”.
MySQL Enterprise Lock contention can seriously degrade performance. The MySQL Enterprise Monitor provides expert advice on avoiding this problem. To subscribe see http://www.mysql.com/products/enterprise/advisors.html.
As of MySQL 3.23.7 (3.23.25 for Windows), the
MyISAM
storage engine supports concurrent
inserts to reduce contention between readers and writers for a
given table: If a MyISAM
table has no holes
in the data file (deleted rows in the middle), inserts can be
performed to add rows to the end of the table at the same time
that SELECT
statements are reading rows from
the table. Concurrent inserts are enabled by default, but can be
disabled by setting the concurrent_insert
system variable to 0.
Under circumstances where concurrent inserts can be used, there
is seldom any need to use the DELAYED
modifier for INSERT
statements. See
Section 12.2.4.2, “INSERT DELAYED
Syntax”.
If you are using the update log or binary log, concurrent
inserts are converted to normal inserts for CREATE ...
SELECT
or INSERT ... SELECT
statements. This is done to ensure that you can re-create an
exact copy of your tables by applying the log during a backup
operation. See Section 5.3.4, “The Binary Log”.
With LOAD DATA INFILE
, if you specify
CONCURRENT
with a MyISAM
table that satisfies the condition for concurrent inserts (that
is, it contains no free blocks in the middle), other threads can
retrieve data from the table while LOAD DATA
is executing. Use of the CONCURRENT
option
affects the performance of LOAD DATA
a bit,
even if no other thread is using the table at the same time.
If you specify HIGH_PRIORITY
, it overrides
the effect of the --low-priority-updates
option
if the server was started with that option. It also causes
concurrent inserts not to be used.
For LOCK TABLE
, the difference between
READ LOCAL
and READ
is
that READ LOCAL
allows non-conflicting
INSERT
statements (concurrent inserts) to
execute while the lock is held. However, this cannot be used if
you are going to manipulate the database using processes
external to the server while you hold the lock.
External locking is the use of filesystem locking to manage contention for database tables by multiple processes. External locking is used in situations where a single process such as the MySQL server cannot be assumed to be the only process that requires access to tables. Here are some examples:
If you run multiple servers that use the same database directory (not recommended), each server must have external locking enabled.
If you use myisamchk to perform table
maintenance operations on MyISAM
tables,
you must either ensure that the server is not running, or
that the server has external locking enabled so that it
locks table files as necessary to coordinate with
myisamchk for access to the tables. The
same is true for use of myisampack to
pack MyISAM
tables.
With external locking in effect, each process that requires access to a table acquires a filesystem lock for the table files before proceeding to access the table. If all necessary locks cannot be acquired, the process is blocked from accessing the table until the locks can be obtained (after the process that currently holds the locks releases them).
External locking affects server performance because the server must sometimes wait for other processes before it can access tables.
External locking is unnecessary if you run a single server to access a given data directory (which is the usual case) and if no other programs such as myisamchk need to modify tables while the server is running. If you only read tables with other programs, external locking is not required, although myisamchk might report warnings if the server changes tables while myisamchk is reading them.
With external locking disabled, to use
myisamchk, you must either stop the server
while myisamchk executes or else lock and
flush the tables before running myisamchk.
(See Section 7.5.1, “System Factors and Startup Parameter Tuning”.) To avoid this
requirement as of MySQL 3.23, use the CHECK
TABLE
and REPAIR TABLE
statements
to check and repair MyISAM
tables.
For mysqld, external locking is controlled by
the value of the skip_external_locking
system
variable. (Before MySQL 4.0.3, this variable is named
skip_locking
.) When this variable is enabled,
external locking is disabled, and vice versa. From MySQL 4.0 on,
external locking is disabled by default. Before MySQL 4.0,
external locking is enabled by default on Linux or when MySQL is
configured to use MIT-pthreads.
Use of external locking can be controlled at server startup by
using the --external-locking
or
--skip-external-locking
option. (Before MySQL
4.0.3, these options are named --enable-locking
and --skip-locking
.)
If you do use external locking option to enable updates to
MyISAM
tables from many MySQL processes, you
must ensure that the following conditions are satisfied:
You should not use the query cache for queries that use tables that are updated by another process.
You should not start the server with the
--delay-key-write=ALL
option or use the
DELAY_KEY_WRITE=1
table option for any
shared tables. Otherise, index corruption can occur.
The easiest way to satisfy these conditions is to always use
--external-locking
together with
--delay-key-write=OFF
and
--query-cache-size=0
. (This is not done by
default because in many setups it is useful to have a mixture of
the preceding options.)
MyISAM
Key CacheMyISAM
Index Statistics CollectionMySQL keeps row data and index data in separate files. Many (almost all) other database systems mix row and index data in the same file. We believe that the MySQL choice is better for a very wide range of modern systems.
Another way to store the row data is to keep the information for each column in a separate area (examples are SDBM and Focus). This causes a performance hit for every query that accesses more than one column. Because this degenerates so quickly when more than one column is accessed, we believe that this model is not good for general-purpose databases.
The more common case is that the index and data are stored together (as in Oracle/Sybase, et al). In this case, you find the row information at the leaf page of the index. The good thing with this layout is that it, in many cases, depending on how well the index is cached, saves a disk read. The bad things with this layout are:
Table scanning is much slower because you have to read through the indexes to get at the data.
You cannot use only the index table to retrieve data for a query.
You use more space because you must duplicate indexes from the nodes (you cannot store the row in the nodes).
Deletes degenerate the table over time (because indexes in nodes are usually not updated on delete).
It is more difficult to cache only the index data.
One of the most basic optimizations is to design your tables to take as little space on the disk as possible. This can result in huge improvements because disk reads are faster, and smaller tables normally require less main memory while their contents are being actively processed during query execution. Indexing also is a lesser resource burden if done on smaller columns.
MySQL supports many different storage engines (table types) and row formats. For each table, you can decide which storage and indexing method to use. Choosing the proper table format for your application may give you a big performance gain. See Chapter 13, Storage Engines.
You can get better performance for a table and minimize storage space by using the techniques listed here:
Use the most efficient (smallest) data types possible. MySQL
has many specialized types that save disk space and memory.
For example, use the smaller integer types if possible to
get smaller tables. MEDIUMINT
is often a
better choice than INT
because a
MEDIUMINT
column uses 25% less space.
Declare columns to be NOT NULL
if
possible. It makes everything faster and you save one bit
per column. If you really need NULL
in
your application, you should definitely use it. Just avoid
having it on all columns by default.
For MyISAM
tables, if you do not have any
variable-length columns (VARCHAR
,
TEXT
, or BLOB
columns), a fixed-size row format is used. This is faster
but unfortunately may waste some space. See
Section 13.1.3, “MyISAM
Table Storage Formats”. You can hint that
you want to have fixed length rows even if you have
VARCHAR
columns with the CREATE
TABLE
option ROW_FORMAT=FIXED
.
The primary index of a table should be as short as possible. This makes identification of each row easy and efficient.
Create only the indexes that you really need. Indexes are good for retrieval but bad when you need to store data quickly. If you access a table mostly by searching on a combination of columns, create an index on them. The first part of the index should be the column most used. If you always use many columns when selecting from the table, you should use the column with more duplicates first to obtain better compression of the index.
If it is very likely that a string column has a unique
prefix on the first number of characters, it's better to
index only this prefix, using MySQL's support for creating
an index on the leftmost part of the column (see
Section 12.1.4, “CREATE INDEX
Syntax”). Shorter indexes are faster,
not only because they require less disk space, but because
they also give you more hits in the index cache, and thus
fewer disk seeks. See Section 7.5.2, “Tuning Server Parameters”.
In some circumstances, it can be beneficial to split into two a table that is scanned very often. This is especially true if it is a dynamic-format table and it is possible to use a smaller static format table that can be used to find the relevant rows when scanning the table.
All MySQL data types can be indexed. Use of indexes on the
relevant columns is the best way to improve the performance of
SELECT
operations.
The maximum number of indexes per table and the maximum index length is defined per storage engine. See Chapter 13, Storage Engines. All storage engines support at least 16 indexes per table and a total index length of at least 256 bytes. Most storage engines have higher limits.
The MyISAM
and (as of MySQL 4.0.14)
InnoDB
storage engines also support indexing
on BLOB
and TEXT
columns.
When indexing a BLOB
or
TEXT
column, you must
specify a prefix length for the index. For example:
CREATE TABLE test (blob_col BLOB, INDEX(blob_col(10)));
Prefixes can be up to 1000 bytes long (767 bytes for
InnoDB
tables). (Before MySQL 4.1.2, the
limit is 255 bytes for all tables.) Note that prefix limits are
measured in bytes, whereas the prefix length in CREATE
TABLE
statements is interpreted as number of
characters. Be sure to take this into account when
specifying a prefix length for a column that uses a multi-byte
character set.
As of MySQL 3.23.23, you can also create
FULLTEXT
indexes. They are used for full-text
searches. Only the MyISAM
storage engine
supports FULLTEXT
indexes and only for
CHAR
, VARCHAR
, and
TEXT
columns. Indexing always takes place
over the entire column and column prefix indexing is not
supported. For details, see Section 11.8, “Full-Text Search Functions”.
As of MySQL 4.1.0, you can create indexes on spatial data types.
Spatial indexes use R-trees. Currently, only
MyISAM
supports indexes on spatial types.
The MEMORY
(HEAP
) storage
engine uses HASH
indexes by default. It also
supports BTREE
indexes as of MySQL 4.1.0.
MySQL can create composite indexes (that is, indexes on multiple columns). An index may consist of up to 15 columns. For certain data types, you can index a prefix of the column (see Section 7.4.3, “Column Indexes”).
A multiple-column index can be considered a sorted array containing values that are created by concatenating the values of the indexed columns.
MySQL uses multiple-column indexes in such a way that queries
are fast when you specify a known quantity for the first column
of the index in a WHERE
clause, even if you
do not specify values for the other columns.
Suppose that a table has the following specification:
CREATE TABLE test ( id INT NOT NULL, last_name CHAR(30) NOT NULL, first_name CHAR(30) NOT NULL, PRIMARY KEY (id), INDEX name (last_name,first_name) );
The name
index is an index over the
last_name
and first_name
columns. The index can be used for queries that specify values
in a known range for last_name
, or for both
last_name
and first_name
.
Therefore, the name
index is used in the
following queries:
SELECT * FROM test WHERE last_name='Widenius'; SELECT * FROM test WHERE last_name='Widenius' AND first_name='Michael'; SELECT * FROM test WHERE last_name='Widenius' AND (first_name='Michael' OR first_name='Monty'); SELECT * FROM test WHERE last_name='Widenius' AND first_name >='M' AND first_name < 'N';
However, the name
index is
not used in the following queries:
SELECT * FROM test WHERE first_name='Michael'; SELECT * FROM test WHERE last_name='Widenius' OR first_name='Michael';
The manner in which MySQL uses indexes to improve query performance is discussed further in Section 7.4.5, “How MySQL Uses Indexes”.
Indexes are used to find rows with specific column values quickly. Without an index, MySQL must begin with the first row and then read through the entire table to find the relevant rows. The larger the table, the more this costs. If the table has an index for the columns in question, MySQL can quickly determine the position to seek to in the middle of the data file without having to look at all the data. If a table has 1,000 rows, this is at least 100 times faster than reading sequentially. If you need to access most of the rows, it is faster to read sequentially, because this minimizes disk seeks.
Most MySQL indexes (PRIMARY KEY
,
UNIQUE
, INDEX
, and
FULLTEXT
) are stored in B-trees. Exceptions
are that indexes on spatial data types use R-trees, and that
MEMORY
(HEAP
) tables
support hash indexes.
Strings are automatically prefix- and end-space compressed. See
Section 12.1.4, “CREATE INDEX
Syntax”.
In general, indexes are used as described in the following
discussion. Characteristics specific to hash indexes (as used in
MEMORY
tables) are described at the end of
this section.
MySQL uses indexes for these operations:
To find the rows matching a WHERE
clause
quickly.
To eliminate rows from consideration. If there is a choice between multiple indexes, MySQL normally uses the index that finds the smallest number of rows.
To retrieve rows from other tables when performing joins.
MySQL can use indexes on columns more efficiently if they
are declared as the same type and size. In this context,
VARCHAR
and CHAR
are
considered the same if they are declared as the same size.
For example, VARCHAR(10)
and
CHAR(10)
are the same size, but
VARCHAR(10)
and
CHAR(15)
are not.
Comparison of dissimilar columns may prevent use of indexes
if values cannot be compared directly without conversion.
Suppose that a numeric column is compared to a string
column. For a given value such as 1
in
the numeric column, it might compare equal to any number of
values in the string column such as '1'
,
' 1'
, '00001'
, or
'01.e1'
. This rules out use of any
indexes for the string column.
To find the MIN()
or
MAX()
value for a specific
indexed column key_col
. This is
optimized by a preprocessor that checks whether you are
using WHERE
on all key
parts that occur before key_part_N
=
constant
key_col
in the index. In this case, MySQL does a single key lookup
for each MIN()
or
MAX()
expression and
replaces it with a constant. If all expressions are replaced
with constants, the query returns at once. For example:
SELECT MIN(key_part2
),MAX(key_part2
) FROMtbl_name
WHEREkey_part1
=10;
To sort or group a table if the sorting or grouping is done
on a leftmost prefix of a usable key (for example,
ORDER BY
). If all key
parts are followed by key_part1
,
key_part2
DESC
, the key is
read in reverse order. See
Section 7.2.8, “ORDER BY
Optimization”.
In some cases, a query can be optimized to retrieve values without consulting the data rows. If a query uses only columns from a table that are numeric and that form a leftmost prefix for some key, the selected values may be retrieved from the index tree for greater speed:
SELECTkey_part3
FROMtbl_name
WHEREkey_part1
=1
Suppose that you issue the following SELECT
statement:
mysql> SELECT * FROM tbl_name
WHERE col1=val1
AND col2=val2
;
If a multiple-column index exists on col1
and
col2
, the appropriate rows can be fetched
directly. If separate single-column indexes exist on
col1
and col2
, the
optimizer tries to find the most restrictive index by deciding
which index finds fewer rows and using that index to fetch the
rows.
If the table has a multiple-column index, any leftmost prefix of
the index can be used by the optimizer to find rows. For
example, if you have a three-column index on (col1,
col2, col3)
, you have indexed search capabilities on
(col1)
, (col1, col2)
, and
(col1, col2, col3)
.
MySQL cannot use an index if the columns do not form a leftmost
prefix of the index. Suppose that you have the
SELECT
statements shown here:
SELECT * FROMtbl_name
WHERE col1=val1
; SELECT * FROMtbl_name
WHERE col1=val1
AND col2=val2
; SELECT * FROMtbl_name
WHERE col2=val2
; SELECT * FROMtbl_name
WHERE col2=val2
AND col3=val3
;
If an index exists on (col1, col2, col3)
,
only the first two queries use the index. The third and fourth
queries do involve indexed columns, but
(col2)
and (col2, col3)
are not leftmost prefixes of (col1, col2,
col3)
.
A B-tree index can be used for column comparisons in expressions
that use the
=
,
>
,
>=
,
<
,
<=
,
or BETWEEN
operators. The
index also can be used for
LIKE
comparisons if the
argument to LIKE
is a constant
string that does not start with a wildcard character. For
example, the following SELECT
statements use
indexes:
SELECT * FROMtbl_name
WHEREkey_col
LIKE 'Patrick%'; SELECT * FROMtbl_name
WHEREkey_col
LIKE 'Pat%_ck%';
In the first statement, only rows with 'Patrick' <=
are
considered. In the second statement, only rows with
key_col
< 'Patricl''Pat' <=
are considered.
key_col
<
'Pau'
The following SELECT
statements do not use
indexes:
SELECT * FROMtbl_name
WHEREkey_col
LIKE '%Patrick%'; SELECT * FROMtbl_name
WHEREkey_col
LIKEother_col
;
In the first statement, the
LIKE
value begins with a
wildcard character. In the second statement, the
LIKE
value is not a constant.
MySQL 4.0 and later versions perform an additional
LIKE
optimization. If you use
... LIKE
'%
and
string
%'string
is longer than three
characters, MySQL uses the Turbo Boyer-Moore
algorithm to initialize the pattern for the string
and then uses this pattern to perform the search more quickly.
A search using
employs indexes if
col_name
IS
NULLcol_name
is indexed.
Any index that does not span all
AND
levels in the
WHERE
clause is not used to optimize the
query. In other words, to be able to use an index, a prefix of
the index must be used in every
AND
group.
The following WHERE
clauses use indexes:
... WHEREindex_part1
=1 ANDindex_part2
=2 ANDother_column
=3 /*index
= 1 ORindex
= 2 */ ... WHEREindex
=1 OR A=10 ANDindex
=2 /* optimized like "index_part1
='hello'" */ ... WHEREindex_part1
='hello' ANDindex_part3
=5 /* Can use index onindex1
but not onindex2
orindex3
*/ ... WHEREindex1
=1 ANDindex2
=2 ORindex1
=3 ANDindex3
=3;
These WHERE
clauses do
not use indexes:
/*index_part1
is not used */ ... WHEREindex_part2
=1 ANDindex_part3
=2 /* Index is not used in both parts of the WHERE clause */ ... WHEREindex
=1 OR A=10 /* No index spans all rows */ ... WHEREindex_part1
=1 ORindex_part2
=10
Sometimes MySQL does not use an index, even if one is available.
One circumstance under which this occurs is when the optimizer
estimates that using the index would require MySQL to access a
very large percentage of the rows in the table. (In this case, a
table scan is likely to be much faster because it requires fewer
seeks.) However, if such a query uses LIMIT
to retrieve only some of the rows, MySQL uses an index anyway,
because it can much more quickly find the few rows to return in
the result.
Hash indexes have somewhat different characteristics from those just discussed:
They are used only for equality comparisons that use the
=
or <=>
operators (but are very fast). They are
not used for comparison operators such as
<
that find a range of values.
The optimizer cannot use a hash index to speed up
ORDER BY
operations. (This type of index
cannot be used to search for the next entry in order.)
MySQL cannot determine approximately how many rows there are
between two values (this is used by the range optimizer to
decide which index to use). This may affect some queries if
you change a MyISAM
table to a
hash-indexed MEMORY
table.
Only whole keys can be used to search for a row. (With a B-tree index, any leftmost prefix of the key can be used to find rows.)
MySQL Enterprise Often, it is not possible to predict exactly what indexes will be required or will be most efficient — actual table usage is the best indicator. The MySQL Enterprise Monitor provides expert advice on this topic. For more information see http://www.mysql.com/products/enterprise/advisors.html.
To minimize disk I/O, the MyISAM
storage
engine exploits a strategy that is used by many database
management systems. It employs a cache mechanism to keep the
most frequently accessed table blocks in memory:
For index blocks, a special structure called the key cache (or key buffer) is maintained. The structure contains a number of block buffers where the most-used index blocks are placed.
For data blocks, MySQL uses no special cache. Instead it relies on the native operating system filesystem cache.
This section first describes the basic operation of the
MyISAM
key cache. Then it discusses changes
made in MySQL 4.1 that improve key cache performance and that
enable you to better control cache operation:
Access to the key cache no longer is serialized among threads. Multiple threads can access the cache concurrently.
You can set up multiple key caches and assign table indexes to specific caches.
The key cache mechanism also is used for ISAM
tables. However, the significance of this fact is on the wane.
ISAM
table use has been decreasing since
MySQL 3.23 when MyISAM
was introduced. MySQL
4.1 carries this trend further; the ISAM
storage engine is disabled by default. (Subsequent MySQL release
series have no support at all for ISAM
.)
To control the size of the key cache, use the
key_buffer_size
system variable. If this
variable is set equal to zero, no key cache is used. The key
cache also is not used if the key_buffer_size
value is too small to allocate the minimal number of block
buffers (8).
MySQL Enterprise
For expert advice on identifying the optimum size for
key_buffer_size
, subscribe to the MySQL
Enterprise Monitor. See
http://www.mysql.com/products/enterprise/advisors.html.
When the key cache is not operational, index files are accessed using only the native filesystem buffering provided by the operating system. (In other words, table index blocks are accessed using the same strategy as that employed for table data blocks.)
An index block is a contiguous unit of access to the
MyISAM
index files. Usually the size of an
index block is equal to the size of nodes of the index B-tree.
(Indexes are represented on disk using a B-tree data structure.
Nodes at the bottom of the tree are leaf nodes. Nodes above the
leaf nodes are non-leaf nodes.)
All block buffers in a key cache structure are the same size. This size can be equal to, greater than, or less than the size of a table index block. Usually one these two values is a multiple of the other.
When data from any table index block must be accessed, the server first checks whether it is available in some block buffer of the key cache. If it is, the server accesses data in the key cache rather than on disk. That is, it reads from the cache or writes into it rather than reading from or writing to disk. Otherwise, the server chooses a cache block buffer containing a different table index block (or blocks) and replaces the data there by a copy of required table index block. As soon as the new index block is in the cache, the index data can be accessed.
If it happens that a block selected for replacement has been modified, the block is considered “dirty.” In this case, prior to being replaced, its contents are flushed to the table index from which it came.
Usually the server follows an LRU (Least Recently Used) strategy: When choosing a block for replacement, it selects the least recently used index block. To make this choice easier, the key cache module maintains a special queue (LRU chain) of all used blocks. When a block is accessed, it is placed at the end of the queue. When blocks need to be replaced, blocks at the beginning of the queue are the least recently used and become the first candidates for eviction.
Prior to MySQL 4.1, access to the key cache is serialized: No two threads can access key cache buffers simultaneously. The server processes a request for an index block only after it has finished processing the previous request. As a result, a request for an index block not present in any key cache buffer blocks access by other threads while a buffer is being updated to contain the requested index block.
Starting from version 4.1.0, the server supports shared access to the key cache:
A buffer that is not being updated can be accessed by multiple threads.
A buffer that is being updated causes threads that need to use it to wait until the update is complete.
Multiple threads can initiate requests that result in cache block replacements, as long as they do not interfere with each other (that is, as long as they need different index blocks, and thus cause different cache blocks to be replaced).
Shared access to the key cache enables the server to improve throughput significantly.
Shared access to the key cache improves performance but does not eliminate contention among threads entirely. They still compete for control structures that manage access to the key cache buffers. To reduce key cache access contention further, MySQL 4.1.1 also provides multiple key caches. This feature enables you to assign different table indexes to different key caches.
Where there are multiple key caches, the server must know
which cache to use when processing queries for a given
MyISAM
table. By default, all
MyISAM
table indexes are cached in the
default key cache. To assign table indexes to a specific key
cache, use the CACHE INDEX
statement (see
Section 12.5.5.1, “CACHE INDEX
Syntax”). For example, the following
statement assigns indexes from the tables
t1
, t2
, and
t3
to the key cache named
hot_cache
:
mysql> CACHE INDEX t1, t2, t3 IN hot_cache;
+---------+--------------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+---------+--------------------+----------+----------+
| test.t1 | assign_to_keycache | status | OK |
| test.t2 | assign_to_keycache | status | OK |
| test.t3 | assign_to_keycache | status | OK |
+---------+--------------------+----------+----------+
If the server has been built with the
ISAM
storage engine enabled,
ISAM
tables use the key cache mechanism.
However, ISAM
indexes use only the
default key cache and cannot be reassigned to a different
cache.
The key cache referred to in a CACHE INDEX
statement can be created by setting its size with a
SET GLOBAL
parameter setting statement or
by using server startup options. For example:
mysql> SET GLOBAL keycache1.key_buffer_size=128*1024;
To destroy a key cache, set its size to zero:
mysql> SET GLOBAL keycache1.key_buffer_size=0;
Note that you cannot destroy the default key cache. Any attempt to do this will be ignored:
mysql>SET GLOBAL key_buffer_size = 0;
mysql>SHOW VARIABLES LIKE 'key_buffer_size';
+-----------------+---------+ | Variable_name | Value | +-----------------+---------+ | key_buffer_size | 8384512 | +-----------------+---------+
Key cache variables are structured system variables that have
a name and components. For
keycache1.key_buffer_size
,
keycache1
is the cache variable name and
key_buffer_size
is the cache component. See
Section 5.1.4.1, “Structured System Variables”, for a
description of the syntax used for referring to structured key
cache system variables.
By default, table indexes are assigned to the main (default) key cache created at the server startup. When a key cache is destroyed, all indexes assigned to it are reassigned to the default key cache.
For a busy server, we recommend a strategy that uses three key caches:
A “hot” key cache that takes up 20% of the space allocated for all key caches. Use this for tables that are heavily used for searches but that are not updated.
A “cold” key cache that takes up 20% of the space allocated for all key caches. Use this cache for medium-sized, intensively modified tables, such as temporary tables.
A “warm” key cache that takes up 60% of the key cache space. Employ this as the default key cache, to be used by default for all other tables.
One reason the use of three key caches is beneficial is that access to one key cache structure does not block access to the others. Statements that access tables assigned to one cache do not compete with statements that access tables assigned to another cache. Performance gains occur for other reasons as well:
The hot cache is used only for retrieval queries, so its contents are never modified. Consequently, whenever an index block needs to be pulled in from disk, the contents of the cache block chosen for replacement need not be flushed first.
For an index assigned to the hot cache, if there are no queries requiring an index scan, there is a high probability that the index blocks corresponding to non-leaf nodes of the index B-tree remain in the cache.
An update operation most frequently executed for temporary tables is performed much faster when the updated node is in the cache and need not be read in from disk first. If the size of the indexes of the temporary tables are comparable with the size of cold key cache, the probability is very high that the updated node is in the cache.
CACHE INDEX
sets up an association between
a table and a key cache, but the association is lost each time
the server restarts. If you want the association to take
effect each time the server starts, one way to accomplish this
is to use an option file: Include variable settings that
configure your key caches, and an init-file
option that names a file containing CACHE
INDEX
statements to be executed. For example:
key_buffer_size = 4G hot_cache.key_buffer_size = 2G cold_cache.key_buffer_size = 2G init_file=/path
/to
/data-directory
/mysqld_init.sql
MySQL Enterprise
For advice on how best to configure your
my.cnf/my.ini
option file subscribe to
MySQL Enterprise Monitor. Recommendations are based on
actual table usage. For more information see
http://www.mysql.com/products/enterprise/advisors.html.
The statements in mysqld_init.sql
are
executed each time the server starts. The file should contain
one SQL statement per line. The following example assigns
several tables each to hot_cache
and
cold_cache
:
CACHE INDEX db1.t1, db1.t2, db2.t3 IN hot_cache CACHE INDEX db1.t4, db2.t5, db2.t6 IN cold_cache
By default, the key cache management system of MySQL 4.1 uses the LRU strategy for choosing key cache blocks to be evicted, but it also supports a more sophisticated method called the midpoint insertion strategy.
When using the midpoint insertion strategy, the LRU chain is
divided into two parts: a hot sub-chain and a warm sub-chain.
The division point between two parts is not fixed, but the key
cache management system takes care that the warm part is not
“too short,” always containing at least
key_cache_division_limit
percent of the key
cache blocks. key_cache_division_limit
is a
component of structured key cache variables, so its value is a
parameter that can be set per cache.
When an index block is read from a table into the key cache, it is placed at the end of the warm sub-chain. After a certain number of hits (accesses of the block), it is promoted to the hot sub-chain. At present, the number of hits required to promote a block (3) is the same for all index blocks.
A block promoted into the hot sub-chain is placed at the end
of the chain. The block then circulates within this sub-chain.
If the block stays at the beginning of the sub-chain for a
long enough time, it is demoted to the warm chain. This time
is determined by the value of the
key_cache_age_threshold
component of the
key cache.
The threshold value prescribes that, for a key cache
containing N
blocks, the block at
the beginning of the hot sub-chain not accessed within the
last
hits is to be moved to
the beginning of the warm sub-chain. It then becomes the first
candidate for eviction, because blocks for replacement always
are taken from the beginning of the warm sub-chain.
N
×
key_cache_age_threshold / 100
The midpoint insertion strategy allows you to keep more-valued
blocks always in the cache. If you prefer to use the plain LRU
strategy, leave the
key_cache_division_limit
value set to its
default of 100.
The midpoint insertion strategy helps to improve performance
when execution of a query that requires an index scan
effectively pushes out of the cache all the index blocks
corresponding to valuable high-level B-tree nodes. To avoid
this, you must use a midpoint insertion strategy with the
key_cache_division_limit
set to much less
than 100. Then valuable frequently hit nodes are preserved in
the hot sub-chain during an index scan operation as well.
If there are enough blocks in a key cache to hold blocks of an entire index, or at least the blocks corresponding to its non-leaf nodes, it makes sense to preload the key cache with index blocks before starting to use it. Preloading allows you to put the table index blocks into a key cache buffer in the most efficient way: by reading the index blocks from disk sequentially.
Without preloading, the blocks are still placed into the key cache as needed by queries. Although the blocks will stay in the cache, because there are enough buffers for all of them, they are fetched from disk in random order, and not sequentially.
To preload an index into a cache, use the LOAD INDEX
INTO CACHE
statement. For example, the following
statement preloads nodes (index blocks) of indexes of the
tables t1
and t2
:
mysql> LOAD INDEX INTO CACHE t1, t2 IGNORE LEAVES;
+---------+--------------+----------+----------+
| Table | Op | Msg_type | Msg_text |
+---------+--------------+----------+----------+
| test.t1 | preload_keys | status | OK |
| test.t2 | preload_keys | status | OK |
+---------+--------------+----------+----------+
The IGNORE LEAVES
modifier causes only
blocks for the non-leaf nodes of the index to be preloaded.
Thus, the statement shown preloads all index blocks from
t1
, but only blocks for the non-leaf nodes
from t2
.
If an index has been assigned to a key cache using a
CACHE INDEX
statement, preloading places
index blocks into that cache. Otherwise, the index is loaded
into the default key cache.
MySQL 4.1 introduces a new
key_cache_block_size
variable on a per-key
cache basis. This variable specifies the size of the block
buffers for a key cache. It is intended to allow tuning of the
performance of I/O operations for index files.
The best performance for I/O operations is achieved when the size of read buffers is equal to the size of the native operating system I/O buffers. But setting the size of key nodes equal to the size of the I/O buffer does not always ensure the best overall performance. When reading the big leaf nodes, the server pulls in a lot of unnecessary data, effectively preventing reading other leaf nodes.
Currently, you cannot control the size of the index blocks in
a table. This size is set by the server when the
.MYI
index file is created, depending on
the size of the keys in the indexes present in the table
definition. In most cases, it is set equal to the I/O buffer
size.
A key cache can be restructured at any time by updating its parameter values. For example:
mysql> SET GLOBAL cold_cache.key_buffer_size=4*1024*1024;
If you assign to either the key_buffer_size
or key_cache_block_size
key cache component
a value that differs from the component's current value, the
server destroys the cache's old structure and creates a new
one based on the new values. If the cache contains any dirty
blocks, the server saves them to disk before destroying and
re-creating the cache. Restructuring does not occur if you
change other key cache parameters.
When restructuring a key cache, the server first flushes the contents of any dirty buffers to disk. After that, the cache contents become unavailable. However, restructuring does not block queries that need to use indexes assigned to the cache. Instead, the server directly accesses the table indexes using native filesystem caching. Filesystem caching is not as efficient as using a key cache, so although queries execute, a slowdown can be anticipated. After the cache has been restructured, it becomes available again for caching indexes assigned to it, and the use of filesystem caching for the indexes ceases.
Storage engines collect statistics about tables for use by the optimizer. Table statistics are based on value groups, where a value group is a set of rows with the same key prefix value. For optimizer purposes, an important statistic is the average value group size.
MySQL uses the average value group size in the following ways:
To estimate how may rows must be read for each
ref
access
To estimate how many row a partial join will produce; that is, the number of rows that an operation of this form will produce:
(...) JOINtbl_name
ONtbl_name
.key
=expr
As the average value group size for an index increases, the index is less useful for those two purposes because the average number of rows per lookup increases: For the index to be good for optimization purposes, it is best that each index value target a small number of rows in the table. When a given index value yields a large number of rows, the index is less useful and MySQL is less likely to use it.
The average value group size is related to table cardinality,
which is the number of value groups. The SHOW
INDEX
statement displays a cardinality value based on
N
/S
, where
N
is the number of rows in the table
and S
is the average value group
size. That ratio yields an approximate number of value groups in
the table.
For a join based on the <=>
comparison
operator, NULL
is not treated differently
from any other value: NULL <=> NULL
,
just as
for any other
N
<=>
N
N
.
However, for a join based on the =
operator,
NULL
is different from
non-NULL
values:
is not true when
expr1
=
expr2
expr1
or
expr2
(or both) are
NULL
. This affects ref
accesses for comparisons of the form
: MySQL will not access
the table if the current value of
tbl_name.key
=
expr
expr
is NULL
,
because the comparison cannot be true.
For =
comparisons, it does not matter how
many NULL
values are in the table. For
optimization purposes, the relevant value is the average size of
the non-NULL
value groups. However, MySQL
does not currently allow that average size to be collected or
used.
For MyISAM
tables, you have some control over
collection of table statistics by means of the
myisam_stats_method
system variable. This
variable has two possible values, which differ as follows:
When myisam_stats_method
is
nulls_equal
, all NULL
values are treated as identical (that is, they all form a
single value group).
If the NULL
value group size is much
higher than the average non-NULL
value
group size, this method skews the average value group size
upward. This makes index appear to the optimizer to be less
useful than it really is for joins that look for
non-NULL
values. Consequently, the
nulls_equal
method may cause the
optimizer not to use the index for ref
accesses when it should.
When myisam_stats_method
is
nulls_unequal
, NULL
values are not considered the same. Instead, each
NULL
value forms a separate value group
of size 1.
If you have many NULL
values, this method
skews the average value group size downward. If the average
non-NULL
value group size is large,
counting NULL
values each as a group of
size 1 causes the optimizer to overestimate the value of the
index for joins that look for non-NULL
values. Consequently, the nulls_unequal
method may cause the optimizer to use this index for
ref
lookups when other methods may be
better.
If you tend to use many joins that use
<=>
rather than =
,
NULL
values are not special in comparisons
and one NULL
is equal to another. In this
case, nulls_equal
is the appropriate
statistics method.
The myisam_stats_method
system variable has
global and session values. Setting the global value affects
MyISAM
statistics collection for all
MyISAM
tables. Setting the session value
affects statistics collection only for the current client
connection. This means that you can force a table's statistics
to be regenerated with a given method without affecting other
clients by setting the session value of
myisam_stats_method
.
To regenerate table statistics, you can use any of the following methods:
Set myisam_stats_method
, and then issue a
CHECK TABLE
statement
Execute myisamchk
--stats_method=method_name
--analyze
Change the table to cause its statistics to go out of date
(for example, insert a row and then delete it), and then set
myisam_stats_method
and issue an
ANALYZE TABLE
statement
Some caveats regarding the use of
myisam_stats_method
:
You can force table statistics to be collected explicitly,
as just described. However, MySQL may also collect
statistics automatically. For example, if during the course
of executing statements for a table, some of those
statements modify the table, MySQL may collect statistics.
(This may occur for bulk inserts or deletes, or some
ALTER TABLE
statements, for example.) If
this happens, the statistics are collected using whatever
value myisam_stats_method
has at the
time. Thus, if you collect statistics using one method, but
myisam_stats_method
is set to the other
method when a table's statistics are collected automatically
later, the other method will be used.
There is no way to tell which method was used to generate
statistics for a given MyISAM
table.
myisam_stats_method
applies only to
MyISAM
tables. Other storage engines have
only one method for collecting table statistics. Usually it
is closer to the nulls_equal
method.
When you execute a mysqladmin status command, you should see something like this:
Uptime: 426 Running threads: 1 Questions: 11082 Reloads: 1 Open tables: 12
The Open tables
value of 12 can be somewhat
puzzling if you have only six tables.
MySQL is multi-threaded, so there may be many clients issuing
queries for a given table simultaneously. To minimize the
problem with multiple client threads having different states on
the same table, the table is opened independently by each
concurrent thread. This uses additional memory but normally
increases performance. With MyISAM
tables,
one extra file descriptor is required for the data file for each
client that has the table open. (By contrast, the index file
descriptor is shared between all threads.)
The table_cache
,
max_connections
, and
max_tmp_tables
system variables affect the
maximum number of files the server keeps open. If you increase
one or more of these values, you may run up against a limit
imposed by your operating system on the per-process number of
open file descriptors. Many operating systems allow you to
increase the open-files limit, although the method varies widely
from system to system. Consult your operating system
documentation to determine whether it is possible to increase
the limit and how to do so.
table_cache
is related to
max_connections
. For example, for 200
concurrent running connections, you should have a table cache
size of at least 200 ×
, where
N
N
is the maximum number of tables per
join in any of the queries which you execute. You must also
reserve some extra file descriptors for temporary tables and
files.
Make sure that your operating system can handle the number of
open file descriptors implied by the
table_cache
setting. If
table_cache
is set too high, MySQL may run
out of file descriptors and refuse connections, fail to perform
queries, and be very unreliable. You also have to take into
account that the MyISAM
storage engine needs
two file descriptors for each unique open table. You can
increase the number of file descriptors available to MySQL using
the --open-files-limit
startup option to
mysqld. See
Section A.1.2.18, “'File
' Not Found and
Similar Errors”.
The cache of open tables is kept at a level of
table_cache
entries. The default value is 64;
this can be changed with the --table_cache
option to mysqld. Note that MySQL may
temporarily open more tables than this to execute queries.
MySQL Enterprise
Performance may suffer if table_cache
is
set too low. For expert advice on the optimum value for this
variable, subscribe to the MySQL Enterprise Monitor. For more
information see
http://www.mysql.com/products/enterprise/advisors.html.
MySQL closes an unused table and removes it from the table cache under the following circumstances:
When the cache is full and a thread tries to open a table that is not in the cache.
When the cache contains more than
table_cache
entries and a table in the
cache is no longer being used by any threads.
When a table flushing operation occurs. This happens when
someone issues a FLUSH TABLES
statement
or executes a mysqladmin flush-tables or
mysqladmin refresh command.
When the table cache fills up, the server uses the following procedure to locate a cache entry to use:
Tables that are not currently in use are released, beginning with the table least recently used.
If a new table needs to be opened, but the cache is full and no tables can be released, the cache is temporarily extended as necessary.
When the cache is in a temporarily extended state and a table goes from a used to unused state, the table is closed and released from the cache.
A table is opened for each concurrent access. This means the
table needs to be opened twice if two threads access the same
table or if a thread accesses the table twice in the same query
(for example, by joining the table to itself). Each concurrent
open requires an entry in the table cache. The first open of any
MyISAM
table takes two file descriptors: one
for the data file and one for the index file. Each additional
use of the table takes only one file descriptor for the data
file. The index file descriptor is shared among all threads.
If you are opening a table with the HANDLER
statement, a
dedicated table object is allocated for the thread. This table
object is not shared by other threads and is not closed until
the thread calls tbl_name
OPENHANDLER
or the
thread terminates. When this happens, the table is put back in
the table cache (if the cache is not full). See
Section 12.2.3, “tbl_name
CLOSEHANDLER
Syntax”.
You can determine whether your table cache is too small by
checking the mysqld status variable
Opened_tables
:
mysql> SHOW STATUS LIKE 'Opened_tables';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| Opened_tables | 2741 |
+---------------+-------+
If the value is very large, even when you have not issued many
FLUSH TABLES
statements, you should increase
the table cache size. See
Section 5.1.3, “System Variables”, and
Section 5.1.5, “Status Variables”.
If you have many MyISAM
or
ISAM
tables in a database directory, open,
close, and create operations are slow. If you execute
SELECT
statements on many different tables,
there is a little overhead when the table cache is full, because
for every table that has to be opened, another must be closed.
You can reduce this overhead by increasing the number of entries
allowed in the table cache.
We start with system-level factors, because some of these decisions must be made very early to achieve large performance gains. In other cases, a quick look at this section may suffice. However, it is always nice to have a sense of how much can be gained by changing factors that apply at this level.
The operating system to use is very important. To get the best use of multiple-CPU machines, you should use Solaris (because its threads implementation works well) or Linux (because the 2.4 and later kernels have good SMP support). Note that older Linux kernels have a 2GB filesize limit by default. If you have such a kernel and a need for files larger than 2GB, you should get the Large File Support (LFS) patch for the ext2 filesystem. Other filesystems such as ReiserFS and XFS do not have this 2GB limitation.
Before using MySQL in production, we advise you to test it on your intended platform.
Other tips:
If you have enough RAM, you could remove all swap devices. Some operating systems use a swap device in some contexts even if you have free memory.
Use the --skip-external-locking
MySQL
option to avoid external locking. This option is turned on
by default as of MySQL 4.0. Before that, it is on by default
when compiling with MIT-pthreads, because
flock()
is not fully supported by
MIT-pthreads on all platforms. It is also on by default for
Linux because Linux file locking is not yet safe.
Note that disabling external locking does not affect MySQL's functionality as long as you run only one server. Just remember to take down the server (or lock and flush the relevant tables) before you run myisamchk. On some systems it is mandatory to disable external locking because it does not work, anyway.
The only case in which you cannot disable external locking is when you run multiple MySQL servers (not clients) on the same data, or if you run myisamchk to check (not repair) a table without telling the server to flush and lock the tables first. Note that using multiple MySQL servers to access the same data concurrently is generally not recommended, except when using MySQL Cluster.
The LOCK TABLES
and UNLOCK
TABLES
statements use internal locking, so you can
use them even if external locking is disabled.
You can determine the default buffer sizes used by the
mysqld server with this command (prior to
MySQL 4.1, omit --verbose
):
shell> mysqld --verbose --help
This command produces a list of all mysqld options and configurable system variables. The output includes the default variable values and looks something like this:
back_log current value: 5 bdb_cache_size current value: 1048540 binlog_cache_size current value: 32768 connect_timeout current value: 5 delayed_insert_limit current value: 100 delayed_insert_timeout current value: 300 delayed_queue_size current value: 1000 flush_time current value: 0 interactive_timeout current value: 28800 join_buffer_size current value: 131072 key_buffer_size current value: 1048540 long_query_time current value: 10 lower_case_table_names current value: 0 max_allowed_packet current value: 1048576 max_binlog_cache_size current value: 4294967295 max_connect_errors current value: 10 max_connections current value: 100 max_delayed_threads current value: 20 max_heap_table_size current value: 16777216 max_join_size current value: 4294967295 max_sort_length current value: 1024 max_tmp_tables current value: 32 max_write_lock_count current value: 4294967295 myisam_sort_buffer_size current value: 8388608 net_buffer_length current value: 16384 net_read_timeout current value: 30 net_retry_count current value: 10 net_write_timeout current value: 60 read_buffer_size current value: 131072 read_rnd_buffer_size current value: 262144 slow_launch_time current value: 2 sort_buffer current value: 2097116 table_cache current value: 64 thread_concurrency current value: 10 thread_stack current value: 131072 tmp_table_size current value: 1048576 wait_timeout current value: 28800
For a mysqld server that is currently running, you can see the current values of its system variables by connecting to it and issuing this statement:
mysql> SHOW VARIABLES;
You can also see some statistical and status indicators for a running server by issuing this statement:
mysql> SHOW STATUS;
System variable and status information also can be obtained using mysqladmin:
shell>mysqladmin variables
shell>mysqladmin extended-status
For a full description of all system and status variables, see Section 5.1.3, “System Variables”, and Section 5.1.5, “Status Variables”.
MySQL uses algorithms that are very scalable, so you can usually run with very little memory. However, normally you get better performance by giving MySQL more memory.
When tuning a MySQL server, the two most important variables to
configure are key_buffer_size
and
table_cache
. You should first feel confident
that you have these set appropriately before trying to change
any other variables.
The following examples indicate some typical variable values for
different runtime configurations. The examples use the
mysqld_safe script and use
--
syntax to set the variable var_name
=value
var_name
to the value value
. This syntax is
available as of MySQL 4.0. For older versions of MySQL, take the
following differences into account:
Use safe_mysqld rather than mysqld_safe.
Set variables using
--set-variable=
or var_name
=value
-O
syntax.
var_name
=value
For variable names that end in _size
, you
may need to specify them without _size
.
For example, the old name for
sort_buffer_size
is
sort_buffer
. The old name for
read_buffer_size
is
record_buffer
. To see which variables
your version of the server recognizes, use mysqld
--help.
If you have at least 256MB of memory and many tables and want maximum performance with a moderate number of clients, you should use something like this:
shell>mysqld_safe --key_buffer_size=64M --table_cache=256 \
--sort_buffer_size=4M --read_buffer_size=1M &
If you have only 128MB of memory and only a few tables, but you still do a lot of sorting, you can use something like this:
shell> mysqld_safe --key_buffer_size=16M --sort_buffer_size=1M
If there are very many simultaneous connections, swapping problems may occur unless mysqld has been configured to use very little memory for each connection. mysqld performs better if you have enough memory for all connections.
With little memory and lots of connections, use something like this:
shell>mysqld_safe --key_buffer_size=512K --sort_buffer_size=100K \
--read_buffer_size=100K &
Or even this:
shell>mysqld_safe --key_buffer_size=512K --sort_buffer_size=16K \
--table_cache=32 --read_buffer_size=8K \
--net_buffer_length=1K &
If you are performing GROUP BY
or
ORDER BY
operations on tables that are much
larger than your available memory, you should increase the value
of read_rnd_buffer_size
to speed up the
reading of rows following sorting operations.
You can make use of the example option files included with your MySQL distribution; see Section 4.2.2.2.2, “Preconfigured Option Files”.
If you specify an option on the command line for mysqld or mysqld_safe, it remains in effect only for that invocation of the server. To use the option every time the server runs, put it in an option file.
To see the effects of a parameter change, do something like this
(prior to MySQL 4.1, omit --verbose
):
shell> mysqld --key_buffer_size=32M --verbose --help
The variable values are listed near the end of the output. Make
sure that the --verbose
and
--help
options are last. Otherwise, the effect
of any options listed after them on the command line are not
reflected in the output.
For information on tuning the InnoDB
storage
engine, see Section 13.2.12, “InnoDB
Performance Tuning Tips”.
MySQL Enterprise For expert advice on tuning system parameters subscribe to the MySQL Enterprise Monitor. For more information see http://www.mysql.com/products/enterprise/advisors.html.
From version 4.0.1 on, MySQL Server features a query cache. When
in use, the query cache stores the text of a
SELECT
statement together with the
corresponding result that was sent to the client. If an
identical statement is received later, the server retrieves the
results from the query cache rather than parsing and executing
the statement again.
The query cache is extremely useful in an environment where you have tables that do not change very often and for which the server receives many identical queries. This is a typical situation for many Web servers that generate many dynamic pages based on database content.
The query cache does not return stale data. When tables are modified, any relevant entries in the query cache are flushed.
The query cache does not work in an environment where you have
multiple mysqld servers updating the same
MyISAM
tables.
The query cache is not used for server-side prepared statements. If you are using server-side prepared statements, consider that these statements will not be satisfied by the query cache. See Section 16.2.4, “C API Prepared Statements”.
Some performance data for the query cache follows. These results were generated by running the MySQL benchmark suite on a Linux Alpha 2×500MHz system with 2GB RAM and a 64MB query cache.
If all the queries you are performing are simple (such as selecting a row from a table with one row), but still differ so that the queries cannot be cached, the overhead for having the query cache active is 13%. This could be regarded as the worst case scenario. In real life, queries tend to be much more complicated, so the overhead normally is significantly lower.
Searches for a single row in a single-row table are 238% faster with the query cache than without it. This can be regarded as close to the minimum speedup to be expected for a query that is cached.
To disable the query cache at server startup, set the
query_cache_size
system variable to 0. By
disabling the query cache code, there is no noticeable overhead.
If you build MySQL from source, query cache capabilities can be
excluded from the server entirely by invoking
configure with the
--without-query-cache
option.
This section describes how the query cache works when it is operational. Section 7.5.3.3, “Query Cache Configuration”, describes how to control whether it is operational.
Incoming queries are compared to those in the query cache before parsing, so the following two queries are regarded as different by the query cache:
SELECT * FROMtbl_name
Select * fromtbl_name
Queries must be exactly the same (byte for byte) to be seen as identical. In addition, query strings that are identical may be treated as different for other reasons. Queries that use different databases, different protocol versions, or different default character sets are considered different queries and are cached separately.
Because comparison of a query against those in the cache occurs before parsing, the cache is not used for queries of the following types:
Prepared statements
Queries that are a subquery of an outer query
Before a query result is fetched from the query cache, MySQL
checks that the user has SELECT
privilege
for all databases and tables involved. If this is not the
case, the cached result is not used.
If a query result is returned from query cache, the server
increments the Qcache_hits
status variable,
not Com_select
. See
Section 7.5.3.4, “Query Cache Status and Maintenance”.
If a table changes, all cached queries that use the table
become invalid and are removed from the cache. This includes
queries that use MERGE
tables that map to
the changed table. A table can be changed by many types of
statements, such as INSERT
,
UPDATE
, DELETE
,
TRUNCATE
, ALTER TABLE
,
DROP TABLE
, or DROP
DATABASE
.
In MySQL 4.0, the query cache is disabled within transactions
(it does not return results). Beginning with MySQL 4.1.1, the
query cache also works within transactions when using
InnoDB
tables.
A query that begins with a leading comment may be cached, but cannot be fetched from the cache.
The query cache works for SELECT SQL_CALC_FOUND_ROWS
...
queries and stores a value that is returned by a
following SELECT FOUND_ROWS()
query.
FOUND_ROWS()
returns the
correct value even if the preceding query was fetched from the
cache because the number of found rows is also stored in the
cache. The SELECT FOUND_ROWS()
query itself
cannot be cached.
A query cannot be cached if it contains any of the functions shown in the following table:
A query also is not cached under these conditions:
It refers to user-defined functions (UDFs).
It refers to user variables.
It refers to tables in the mysql
system
database.
It is of any of the following forms:
SELECT ... IN SHARE MODE SELECT ... FOR UPDATE SELECT ... INTO OUTFILE ... SELECT ... INTO DUMPFILE ... SELECT * FROM ... WHERE autoincrement_col IS NULL
The last form is not cached because it is used as the ODBC workaround for obtaining the last insert ID value. See the MyODBC section of Chapter 17, Connectors.
It was issued as a prepared statement, even if no placeholders were employed. For example, the query used here is not cached:
char *my_sql_stmt = "SELECT a, b FROM table_c"; /* ... */ mysql_stmt_prepare(stmt, my_sql_stmt, strlen(my_sql_stmt));
It uses TEMPORARY
tables.
It does not use any tables.
The user has a column-level privilege for any of the involved tables.
Two query cache-related options may be specified in
SELECT
statements:
Examples:
SELECT SQL_CACHE id, name FROM customer; SELECT SQL_NO_CACHE id, name FROM customer;
The have_query_cache
server system variable
indicates whether the query cache is available:
mysql> SHOW VARIABLES LIKE 'have_query_cache';
+------------------+-------+
| Variable_name | Value |
+------------------+-------+
| have_query_cache | YES |
+------------------+-------+
Several other system variables control query cache operation.
These can be set in an option file or on the command line when
starting mysqld. The query cache system
variables all have names that begin with
query_cache_
. They are described briefly in
Section 5.1.3, “System Variables”, with additional
configuration information given here.
To set the size of the query cache, set the
query_cache_size
system variable. Setting
it to 0 disables the query cache. The default size is 0, so
the query cache is disabled by default.
MySQL Enterprise For expert advice on configuring the query cache subscribe to the MySQL Enterprise Monitor. For more information see, http://www.mysql.com/products/enterprise/advisors.html.
When using the Windows Configuration Wizard to install or
configure MySQL, the default value for
query_cache_size
will be configured
automatically for you based on the different configuration
types available. When using the Windows Configuration
Wizard, the query cache may be enabled (i.e. set to a
non-zero value) due to the selected configuration. The query
cache is also controlled by the setting of the
query_cache_type
variable. You should
check the values of these variables as set in your
my.ini
file after configuration has
taken place.
When you set query_cache_size
to a non-zero
value, keep in mind that the query cache needs a minimum size
of about 40KB to allocate its structures. (The exact size
depends on system architecture.) If you set the value too
small, you'll get a warning, as in this example:
mysql>SET GLOBAL query_cache_size = 40000;
Query OK, 0 rows affected, 1 warning (0.00 sec) mysql>SHOW WARNINGS\G
*************************** 1. row *************************** Level: Warning Code: 1282 Message: Query cache failed to set size 39936; new query cache size is 0 mysql>SET GLOBAL query_cache_size = 41984;
Query OK, 0 rows affected (0.00 sec) mysql>SHOW VARIABLES LIKE 'query_cache_size';
+------------------+-------+ | Variable_name | Value | +------------------+-------+ | query_cache_size | 41984 | +------------------+-------+
For the query cache to actually be able to hold any query results, its size must be set larger:
mysql>SET GLOBAL query_cache_size = 1000000;
Query OK, 0 rows affected (0.04 sec) mysql>SHOW VARIABLES LIKE 'query_cache_size';
+------------------+--------+ | Variable_name | Value | +------------------+--------+ | query_cache_size | 999424 | +------------------+--------+ 1 row in set (0.00 sec)
The query_cache_size
will be aligned to the
nearest 1024 byte block. The value reported may therefore be
different from the value that you set.
If the query cache size is greater than 0, the
query_cache_type
variable influences how it
works. This variable can be set to the following values:
A value of 0
or OFF
prevents caching or retrieval of cached results.
A value of 1
or ON
allows caching except of those statements that begin with
SELECT SQL_NO_CACHE
.
A value of 2
or
DEMAND
causes caching of only those
statements that begin with SELECT
SQL_CACHE
.
Setting the GLOBAL
query_cache_type
value determines query
cache behavior for all clients that connect after the change
is made. Individual clients can control cache behavior for
their own connection by setting the SESSION
query_cache_type
value. For example, a
client can disable use of the query cache for its own queries
like this:
mysql> SET SESSION query_cache_type = OFF;
To control the maximum size of individual query results that
can be cached, set the query_cache_limit
system variable. The default value is 1MB.
When a query is to be cached, its result (the data sent to the
client) is stored in the query cache during result retrieval.
Therefore the data usually is not handled in one big chunk.
The query cache allocates blocks for storing this data on
demand, so when one block is filled, a new block is allocated.
Because memory allocation operation is costly (timewise), the
query cache allocates blocks with a minimum size given by the
query_cache_min_res_unit
system variable.
When a query is executed, the last result block is trimmed to
the actual data size so that unused memory is freed. Depending
on the types of queries your server executes, you might find
it helpful to tune the value of
query_cache_min_res_unit
:
The default value of
query_cache_min_res_unit
is 4KB. This
should be adequate for most cases.
If you have a lot of queries with small results, the
default block size may lead to memory fragmentation, as
indicated by a large number of free blocks. Fragmentation
can force the query cache to prune (delete) queries from
the cache due to lack of memory. In this case, you should
decrease the value of
query_cache_min_res_unit
. The number of
free blocks and queries removed due to pruning are given
by the values of the Qcache_free_blocks
and Qcache_lowmem_prunes
status
variables.
If most of your queries have large results (check the
Qcache_total_blocks
and
Qcache_queries_in_cache
status
variables), you can increase performance by increasing
query_cache_min_res_unit
. However, be
careful to not make it too large (see the previous item).
query_cache_min_res_unit
is present from
MySQL 4.1.
MySQL Enterprise If the query cache is under-utilized, performance will suffer. Advice on avoiding this problem is provided to subscribers to the MySQL Enterprise Monitor. For more information see, http://www.mysql.com/products/enterprise/advisors.html.
You can check whether the query cache is present in your MySQL server using the following statement:
mysql> SHOW VARIABLES LIKE 'have_query_cache';
+------------------+-------+
| Variable_name | Value |
+------------------+-------+
| have_query_cache | YES |
+------------------+-------+
You can defragment the query cache to better utilize its
memory with the FLUSH QUERY CACHE
statement. The statement does not remove any queries from the
cache.
The RESET QUERY CACHE
statement removes all
query results from the query cache. The FLUSH
TABLES
statement also does this.
To monitor query cache performance, use SHOW
STATUS
to view the cache status variables:
mysql> SHOW STATUS LIKE 'Qcache%';
+-------------------------+--------+
| Variable_name | Value |
+-------------------------+--------+
| Qcache_free_blocks | 36 |
| Qcache_free_memory | 138488 |
| Qcache_hits | 79570 |
| Qcache_inserts | 27087 |
| Qcache_lowmem_prunes | 3114 |
| Qcache_not_cached | 22989 |
| Qcache_queries_in_cache | 415 |
| Qcache_total_blocks | 912 |
+-------------------------+--------+
Descriptions of each of these variables are given in Section 5.1.5, “Status Variables”. Some uses for them are described here.
The total number of SELECT
queries is given
by this formula:
Com_select + Qcache_hits + queries with errors found by parser
The Com_select
value is given by this
formula:
Qcache_inserts + Qcache_not_cached + queries with errors found during the column-privileges check
The query cache uses variable-length blocks, so
Qcache_total_blocks
and
Qcache_free_blocks
may indicate query cache
memory fragmentation. After FLUSH QUERY
CACHE
, only a single free block remains.
Every cached query requires a minimum of two blocks (one for the query text and one or more for the query results). Also, every table that is used by a query requires one block. However, if two or more queries use the same table, only one table block needs to be allocated.
The information provided by the
Qcache_lowmem_prunes
status variable can
help you tune the query cache size. It counts the number of
queries that have been removed from the cache to free up
memory for caching new queries. The query cache uses a least
recently used (LRU) strategy to decide which queries to remove
from the cache. Tuning information is given in
Section 7.5.3.3, “Query Cache Configuration”.
When you are attempting to ascertain what your MySQL server is doing, it can be helpful to examine the process list, which is the set of threads currently executing within the server. Process list information is available from these sources:
The SHOW [FULL] PROCESSLIST
statement
(Section 12.5.4.16, “SHOW PROCESSLIST
Syntax”)
The myqladmin processlist command (Section 4.5.2, “mysqladmin — Client for Administering a MySQL Server”)
You can always view information about your own threads. To view
information about threads being executed for other accounts, you
must have the PROCESS
privilege.
Each process list entry contains several pieces of information:
Id
is the connection identifier for the
client associated with the thread.
User
and Host
indicate
the account associated with the thread.
db
is the default database for the
thread, or NULL
if none is selected.
Command
and State
indicate what the thread is doing.
Most states correspond to very quick operations. If a thread stays in a given state for many seconds, there might be a problem that needs to be investigated.
Time
indicates how long the thread has
been in its current state.
Info
contains the text of the statement
being executed by the thread, or NULL
if
it is not executing one. By default, this value contains
only the first 100 characters of the statement. To see the
complete statements, use SHOW FULL
PROCESSLIST
.
The following sections list the possible
Command
values, and State
values grouped by category. The meaning for some of these values
is self-evident. For others, additional description is provided.
A thread can have any of the following
Command
values:
This is a thread on a master server for sending binary log contents to a slave server.
The thread is executing a change-user operation.
The thread is closing a prepared statement.
A replication slave is connected to its master.
A replication slave is connecting to its master.
The thread is executing a create-database operation.
This thread is internal to the server, not a thread that services a client connection.
The thread is generating debugging information.
The thread is a delayed-insert handler.
The thread is executing a drop-database operation.
The thread is executing a prepared statement.
The thread is fetching the results from executing a prepared statement.
The thread is retrieving information for table columns.
The thread is selecting a default database.
The thread is killing another thread.
The thread is retrieving long data in the result of executing a prepared statement.
The thread is handling a server-ping request.
The thread is preparing a prepared statement.
The thread is producing information about server threads.
The thread is executing a statement.
The thread is terminating.
The thread is flushing table, logs, or caches, or resetting status variable or replication server information.
The thread is registering a slave server.
The thread is resetting a prepared statement.
The thread is setting or resetting a client statement-execution option.
The thread is shutting down the server.
The thread is waiting for the client to send a new statement to it.
The thread is producing server-status information.
The thread is sending table contents to a slave server.
Unused.
The following list describes thread State
values that are associated with general query processing and
not more specialized activities such as replication. Many of
these are useful only for finding bugs in the server.
Occurs when the thread creates a table (including internal temporary tables), at the end of the function that creates the table. This state is used even if the table could not be created due to some error.
The thread is calculating a MyISAM
table key distributions (for example, for ANALYZE
TABLE
).
The thread is performing a table check operation.
The thread has processed one command and is preparing to free memory and reset certain state variables.
Means that the thread is flushing the changed table data to disk and closing the used tables. This should be a fast operation. If not, you should verify that you do not have a full disk and that the disk is not in very heavy use.
The thread is converting an internal temporary table from
a MEMORY
table to an on-disk
MyISAM
table.
The thread is processing an ALTER TABLE
statement. This state occurs after the table with the new
structure has been created but before rows are copied into
it.
If a statement has different ORDER BY
and GROUP BY
criteria, the rows are
sorted by group and copied to a temporary table.
The server is copying to a temporary table in memory.
The server is copying to a temporary table on disk. The
temporary result set was larger than
tmp_table_size
and the thread is
changing the temporary table from in-memory to disk-based
format to save memory.
The thread is processing ALTER TABLE ... ENABLE
KEYS
for a MyISAM
table.
The thread is processing a SELECT
that
is resolved using an internal temporary table.
The thread is creating a table. This includes creation of temporary tables.
The thread is creating a temporary table in memory or on
disk. If the table is created in memory but later is
converted to an on-disk table, the state during that
operation will be Copying to tmp table on
disk
.
The server is executing the first part of a multiple-table delete. It is deleting only from the first table, and saving fields and offsets to be used for deleting from the other (reference) tables.
deleting from reference tables
The server is executing the second part of a multiple-table delete and deleting the matched rows from the other tables.
The thread is processing an ALTER TABLE ...
DISCARD TABLESPACE
or ALTER TABLE ...
IMPORT TABLESPACE
statement.
This occurs at the end but before the cleanup of
ALTER TABLE
, DELETE
,
INSERT
, SELECT
, or
UPDATE
statements.
The thread is executing statements in the value of the
init_command
system variable.
The thread has executed a command. This state is usually
followed by cleaning up
.
The thread is executing FLUSH TABLES
and is waiting for all threads to close their tables.
The server is preparing to perform a natural-language full-text search.
This occurs before the initialization of ALTER
TABLE
, DELETE
,
INSERT
, SELECT
, or
UPDATE
statements.
Someone has sent a KILL
statement to
the thread and it should abort next time it checks the
kill flag. The flag is checked in each major loop in
MySQL, but in some cases it might still take a short time
for the thread to die. If the thread is locked by some
other thread, the kill takes effect as soon as the other
thread releases its lock.
The query is locked by another query.
The thread is writing a statement to the slow-query log.
The initial state for a connection thread until the client has been authenticated successfully.
The thread is trying to open a table. This is should be
very fast procedure, unless something prevents opening.
For example, an ALTER TABLE
or a
LOCK TABLE
statement can prevent
opening a table until the statement is finished.
This state occurs during query optimization.
The thread is removing unneeded relay log files.
This state occurs after processing a query but before the
freeing items
state.
The server is reading a packet from the network.
The query was using SELECT DISTINCT
in
such a way that MySQL could not optimize away the distinct
operation at an early stage. Because of this, MySQL
requires an extra stage to remove all duplicated rows
before sending the result to the client.
The thread is removing an internal temporary table after
processing a SELECT
statement. This
state is not used if no temporary table was created.
The thread is renaming a table.
The thread is processing an ALTER TABLE
statement, has created the new table, and is renaming it
to replace the original table.
The thread got a lock for the table, but noticed after getting the lock that the underlying table structure changed. It has freed the lock, closed the table, and is trying to reopen it.
The repair code is using a sort to create indexes.
The thread has completed a multi-threaded repair for a
MyISAM
table.
The repair code is using creating keys one by one through
the key cache. This is much slower than Repair by
sorting
.
The thread is rolling back a transaction.
For MyISAM
table operations such as
repair or analysis, the thread is saving the new table
state to the .MYI
file header. State
includes information such as number of rows, the
AUTO_INCREMENT
counter, and key
distributions.
The thread is doing a first phase to find all matching
rows before updating them. This has to be done if the
UPDATE
is changing the index that is
used to find the involved rows.
Sending data
The thread is processing rows for a
SELECT
statement and also is sending
data to the client.
The thread is beginning an ALTER TABLE
operation.
The thread is doing a sort to satisfy a GROUP
BY
.
The thread is doing a sort to satisfy a ORDER
BY
.
The thread is sorting index pages for more efficient
access during a MyISAM
table
optimization operation.
For a SELECT
statement, this is similar
to Creating sort index
, but for
non-temporary tables.
The server is calculating statistics to develop a query execution plan.
The thread is going to request or is waiting for an
external system lock for the table. If you are not using
multiple mysqld servers that are
accessing the same tables, you can disable system locks
with the --skip-external-locking
option.
The next thread state after System
lock
. The thread has acquired an external lock
and is going to request an internal table lock.
The thread is searching for rows to update and is updating them.
The server is executing the first part of a multiple-table update. It is updating only the first table, and saving fields and offsets to be used for updating the other (reference) tables.
The server is executing the second part of a multiple-table update and updating the matched rows from the other tables.
The thread is going to request or is waiting for an
advisory lock requested with a
GET_LOCK()
call.
Waiting for tables
, Waiting
for table
The thread got a notification that the underlying structure for a table has changed and it needs to reopen the table to get the new structure. However, to reopen the table, it must wait until all other threads have closed the table in question.
This notification takes place if another thread has used
FLUSH TABLES
or one of the following
statements on the table in question: FLUSH TABLES
,
tbl_name
ALTER TABLE
, RENAME
TABLE
, REPAIR TABLE
,
ANALYZE TABLE
, or OPTIMIZE
TABLE
.
A generic state in which the the thread is waiting for a condition to become true. No specific state information is available.
The server is writing a packet to the network.
These thread states are associated with processing for
DELAYED
inserts (see
Section 12.2.4.2, “INSERT DELAYED
Syntax”). Some states are associated
with connection threads that process INSERT
DELAYED
statements from clients. Other states are
associated with delayed-insert handler threads that insert the
rows. There is a delayed-insert handler thread for each table
for which INSERT DELAYED
statements are
issued.
States associated with a connection thread that processes an
INSERT DELAYED
statement from the client:
The thread is preparing to feed rows to the delayed-insert handler thread.
The thread is creating a handler for
DELAYED
inserts.
This occurs before the allocating local
table
state and after the waiting for
handler lock
state, when the connection thread
gets access to the delayed-insert handler thread.
This occurs after the waiting for handler
open
state. The delayed-insert handler thread
has signaled that it has ended its initialization phase,
which includes opening the table for delayed inserts.
The thread is adding a new row to the list of rows that the delayed-insert handler thread must insert.
This occurs during the initialization phase when the thread is trying to find the delayed-insert handler thread for the table, and before attempting to gain access to the list of delayed-insert threads.
An INSERT DELAYED
handler has processed
all pending inserts and is waiting for new ones.
This occurs before the allocating local
table
state when the connection thread waits for
access to the delayed-insert handler thread.
This occurs after the Creating delayed
handler
state and before the got old
table
state. The delayed-insert handler thread
has just been started, and the connection thread is
waiting for it to initialize.
States associated with a delayed-insert handler thread that inserts the rows:
The state that occurs just before inserting rows into the table.
After inserting a number of rows, the delayed-insert thread sleeps to let other threads do work.
A delayed-insert handler is trying to get a lock for the table to insert rows.
A delayed-insert handler is waiting for a connection
thread to add rows to the queue (see storing row
into queue
).
The following list shows the most common states you may see in
the State
column for the master's
Binlog Dump
thread. If you see no
Binlog Dump
threads on a master server,
this means that replication is not running — that is,
that no slaves are currently connected.
Binary logs consist of events, where an event is usually an update plus some other information. The thread has read an event from the binary log and is now sending it to the slave.
Finished reading one binlog; switching to next
binlog
The thread has finished reading a binary log file and is opening the next one to send to the slave.
Has sent all binlog to slave; waiting for binlog
to be updated
The thread has read all outstanding updates from the binary logs and sent them to the slave. The thread is now idle, waiting for new events to appear in the binary log resulting from new updates occurring on the master.
Waiting to finalize termination
A very brief state that occurs as the thread is stopping.
The following list shows the most common states you see in the
State
column for a slave server I/O thread.
Beginning with MySQL 4.1.1, this state also appears in the
Slave_IO_State
column displayed by
SHOW SLAVE STATUS
, so you can get a good
view of what is happening by using that statement.
The initial state before Connecting to
master
.
The thread is attempting to connect to the master.
A state that occurs very briefly, after the connection to the master is established.
A state that occurs very briefly after the connection to the master is established.
A state that occurs very briefly, after the connection to the master is established. The thread sends to the master a request for the contents of its binary logs, starting from the requested binary log filename and position.
Waiting to reconnect after a failed binlog dump
request
If the binary log dump request failed (due to
disconnection), the thread goes into this state while it
sleeps, then tries to reconnect periodically. The interval
between retries can be specified using the
--master-connect-retry
option.
Reconnecting after a failed binlog dump
request
The thread is trying to reconnect to the master.
Waiting for master to send event
The thread has connected to the master and is waiting for
binary log events to arrive. This can last for a long time
if the master is idle. If the wait lasts for
slave_net_timeout
seconds, a timeout
occurs. At that point, the thread considers the connection
to be broken and makes an attempt to reconnect.
Queueing master event to the relay log
The thread has read an event and is copying it to the relay log so that the SQL thread can process it.
Waiting to reconnect after a failed master event
read
An error occurred while reading (due to disconnection).
The thread is sleeping for
master-connect-retry
seconds before
attempting to reconnect.
Reconnecting after a failed master event
read
The thread is trying to reconnect to the master. When
connection is established again, the state becomes
Waiting for master to send event
.
Waiting for the slave SQL thread to free enough
relay log space
You are using a non-zero
relay_log_space_limit
value, and the
relay logs have grown large enough that their combined
size exceeds this value. The I/O thread is waiting until
the SQL thread frees enough space by processing relay log
contents so that it can delete some relay log files.
Waiting for slave mutex on exit
A state that occurs briefly as the thread is stopping.
The following list shows the most common states you may see in
the State
column for a slave server SQL
thread:
Waiting for the next event in relay log
The initial state before Reading event from the
relay log
.
Reading event from the relay log
The thread has read an event from the relay log so that the event can be processed.
Has read all relay log; waiting for the slave I/O
thread to update it
The thread has processed all events in the relay log files, and is now waiting for the I/O thread to write new events to the relay log.
The thread is executing a LOAD DATA
INFILE
statement and is creating a temporary
file containing the data from which the slave will read
rows.
Waiting for slave mutex on exit
A very brief state that occurs as the thread is stopping.
The State
column for the I/O thread may
also show the text of a statement. This indicates that the
thread has read an event from the relay log, extracted the
statement from it, and is executing it.
These thread states occur on a replication slave but are associated with connection threads, not with the I/O or SQL threads.
The thread is processing a CHANGE
MASTER
statement.
Creating table from master dump
The slave is creating a table using the CREATE
TABLE
statement contained in the dump from the
master. Used for LOAD TABLE FROM MASTER
and LOAD DATA FROM MASTER
.
The thread is processing a SLAVE STOP
statement.
This state occurs after Creating table from
master dump
.
Reading master dump table data
This state occurs after Opening master dump
table
.
Rebuilding the index on master dump
table
This state occurs after Reading master dump table
data
.
The thread is starting the slave threads after processing
a successful LOAD DATA FROM MASTER
load
operation.
The thread is processing events for binary logging.
Processing events from schema table
The thread is doing the work of schema replication.
Syncing ndb table schema operation and
binlog
This is used to have a correct binary log of schema operations for NDB.
Waiting for event from ndbcluster
The server is acting as an SQL node in a MySQL Cluster, and is connected to a cluster management node.
Waiting for ndbcluster binlog update to reach
current position
The thread is waiting for a schema epoch (that is, a global checkpoint).
Most of the following tests were performed on Linux with the MySQL benchmarks, but they should give some indication for other operating systems and workloads.
You obtain the fastest executables when you link with
-static
.
On Linux, it is best to compile the server with
pgcc and -O3
. You need about
200MB memory to compile sql_yacc.cc
with
these options, because gcc or
pgcc needs a great deal of memory to make all
functions inline. You should also set CXX=gcc
when configuring MySQL to avoid inclusion of the
libstdc++
library, which is not needed. Note
that with some versions of pgcc, the
resulting binary runs only on true Pentium processors, even if
you use the compiler option indicating that you want the
resulting code to work on all x586-type processors (such as
AMD).
By using a better compiler and compilation options, you can obtain a 10–30% speed increase in applications. This is particularly important if you compile the MySQL server yourself.
When we tested both the Cygnus CodeFusion and Fujitsu compilers, neither was sufficiently bug-free to allow MySQL to be compiled with optimizations enabled.
The standard MySQL binary distributions are compiled with
support for all character sets. When you compile MySQL yourself,
you should include support only for the character sets that you
are going to use. This is controlled by the
--with-charset
option to
configure.
Here is a list of some measurements that we have made:
If you use pgcc and compile everything
with -O6
, the mysqld
server is 1% faster than with gcc 2.95.2.
If you link dynamically (without -static
),
the result is 13% slower on Linux. Note that you still can
use a dynamically linked MySQL library for your client
applications. It is the server that is most critical for
performance.
For a connection from a client to a server running on the
same host, if you connect using TCP/IP rather than a Unix
socket file, performance is 7.5% slower. (On Unix, if you
connect to the hostname localhost
, MySQL
uses a socket file by default.)
For TCP/IP connections from a client to a server, connecting to a remote server on another host is 8–11% slower than connecting to a server on the same host, even for connections over 100Mb/s Ethernet.
When running our benchmark tests using secure connections (all data encrypted with internal SSL support) performance was 55% slower than with unencrypted connections.
If you compile with --with-debug=full
, most
queries are 20% slower. Some queries may take substantially
longer; for example, the MySQL benchmarks run 35% slower. If
you use --with-debug
(without
=full
), the speed decrease is only 15%.
For a version of mysqld that has been
compiled with --with-debug=full
, you can
disable memory checking at runtime by starting it with the
--skip-safemalloc
option. The execution
speed should then be close to that obtained when configuring
with --with-debug
.
On a Sun UltraSPARC-IIe, a server compiled with Forte 5.0 is 4% faster than one compiled with gcc 3.2.
On a Sun UltraSPARC-IIe, a server compiled with Forte 5.0 is 4% faster in 32-bit mode than in 64-bit mode.
Compiling with gcc 2.95.2 for UltraSPARC
with the -mcpu=v8 -Wa,-xarch=v8plusa
options gives 4% more performance.
On Solaris 2.5.1, MIT-pthreads is 8–12% slower than Solaris native threads on a single processor. With greater loads or more CPUs, the difference should be larger.
Compiling on Linux-x86 using gcc without
frame pointers (-fomit-frame-pointer
or
-fomit-frame-pointer -ffixed-ebp
) makes
mysqld 1–4% faster.
Binary MySQL distributions for Linux that are provided by MySQL AB used to be compiled with pgcc. We had to go back to regular gcc due to a bug in pgcc that would generate binaries that do not run on AMD. We will continue using gcc until that bug is resolved. In the meantime, if you have a non-AMD machine, you can build a faster binary by compiling with pgcc. The standard MySQL Linux binary is linked statically to make it faster and more portable.
The following list indicates some of the ways that the mysqld server uses memory. Where applicable, the name of the system variable relevant to the memory use is given:
The key buffer is shared by all threads; its size is
determined by the key_buffer_size
variable. Other buffers used by the server are allocated as
needed. See Section 7.5.2, “Tuning Server Parameters”.
Each connection uses some thread-specific space. The following list indicates these and which variables control their size:
A stack (default 64KB before MySQL 4.0.10 and 192KB
thereafter, variable thread_stack
)
A connection buffer (variable
net_buffer_length
)
A result buffer (variable
net_buffer_length
)
The connection buffer and result buffer both begin with a
size given by net_buffer_length
but are
dynamically enlarged up to
max_allowed_packet
bytes as needed. The
result buffer shrinks to
net_buffer_length
after each SQL
statement. While a statement is running, a copy of the
current statement string is also allocated.
All threads share the same base memory.
When a thread is no longer needed, the memory allocated to it is released and returned to the system unless the thread goes back into the thread cache. In that case, the memory remains allocated.
Only compressed ISAM
and
MyISAM
tables are memory mapped. This is
because the 32-bit memory space of 4GB is not large enough
for most big tables. When systems with a 64-bit address
space become more common, we may add general support for
memory mapping.
Each request that performs a sequential scan of a table
allocates a read buffer (variable
read_buffer_size
).
When reading rows in an arbitrary sequence (for example,
following a sort), a random-read
buffer (variable
read_rnd_buffer_size
) may be allocated in
order to avoid disk seeks.
All joins are executed in a single pass, and most joins can
be done without even using a temporary table. Most temporary
tables are memory-based hash tables. Temporary tables with a
large row length (calculated as the sum of all column
lengths) or that contain BLOB
columns are
stored on disk.
One problem before MySQL 3.23.2 is that if an internal
in-memory heap table exceeds the size of
tmp_table_size
, the error The
table
occurs. From 3.23.2 on, this is handled automatically by
changing the in-memory heap table to a disk-based
tbl_name
is fullMyISAM
table as necessary. To work around
this problem for older servers, you can increase the
temporary table size by setting the
tmp_table_size
option to
mysqld, or by setting the SQL option
SQL_BIG_TABLES
in the client program. See
Section 12.5.3, “SET
Syntax”.
In MySQL 3.20, the maximum size of the temporary table is
record_buffer*16
; if you are using this
version, you have to increase the value of
record_buffer
. You can also start
mysqld with the
--big-tables
option to always store
temporary tables on disk. However, this affects the speed of
many complicated queries.
Most requests that perform a sort allocate a sort buffer and zero to two temporary files depending on the result set size. See Section A.1.4.4, “Where MySQL Stores Temporary Files”.
Almost all parsing and calculating is done in a local memory
store. No memory overhead is needed for small items, so the
normal slow memory allocation and freeing is avoided. Memory
is allocated only for unexpectedly large strings. This is
done with malloc()
and
free()
.
For each MyISAM
or
ISAM
table that is opened, the index file
is opened once and the data file is opened once for each
concurrently running thread. For each concurrent thread, a
table structure, column structures for each column, and a
buffer of size 3 ×
are allocated (where
N
N
is the maximum row length, not
counting BLOB
columns). A
BLOB
column requires five to eight bytes
plus the length of the BLOB
data. The
MyISAM
and ISAM
storage engines maintain one extra row buffer for internal
use.
For each table having BLOB
columns, a
buffer is enlarged dynamically to read in larger
BLOB
values. If you scan a table, a
buffer as large as the largest BLOB
value
is allocated.
Handler structures for all in-use tables are saved in a cache and managed as a FIFO. By default, the cache has 64 entries. If a table has been used by two running threads at the same time, the cache contains two entries for the table. See Section 7.4.8, “How MySQL Opens and Closes Tables”.
A FLUSH TABLES
statement or
mysqladmin flush-tables command closes
all tables that are not in use at once and marks all in-use
tables to be closed when the currently executing thread
finishes. This effectively frees most in-use memory.
FLUSH TABLES
does not return until all
tables have been closed.
ps and other system status programs may
report that mysqld uses a lot of memory. This
may be caused by thread stacks on different memory addresses.
For example, the Solaris version of ps counts
the unused memory between stacks as used memory. You can verify
this by checking available swap with swap -s
.
We test mysqld with several memory-leakage
detectors (both commercial and Open Source), so there should be
no memory leaks.
In some cases, the server creates internal temporary tables
while processing queries. A temporary table can be held in
memory and processed by the MEMORY
storage
engine, or stored on disk and processed by the
MyISAM
storage engine. Temporary tables can
be created under conditions such as these:
If there is an ORDER BY
clause and a
different GROUP BY
clause, or if the
ORDER BY
or GROUP BY
contains columns from tables other than the first table in
the join queue, a temporary table is created.
If you use the SQL_SMALL_RESULT
option,
MySQL uses an in-memory temporary table.
DISTINCT
combined with ORDER
BY
may require a temporary table.
You can tell whether a query requires a temporary table by using
EXPLAIN
and checking the
Extra
column to see whether it says
Using temporary
. See
Section 12.3.2, “EXPLAIN
Syntax”.
Some conditions prevent the use of a MEMORY
temporary table, in which case the server uses a
MyISAM
table instead:
Presence of a TEXT
or
BLOB
column in the table
Presence of any column in a GROUP BY
or
DISTINCT
clause larger than 512 bytes
Presence of any column larger than 512 bytes in the
SELECT
list, if UNION
or UNION ALL
is used.
A temporary table that is created initially as a
MEMORY
table might be converted to a
MyISAM
table and stored on disk if it becomes
too large. The max_heap_table_size
system
variable determines how large MEMORY
tables
are allowed to grow. It applies to all MEMORY
tables, including those created with CREATE
TABLE
. However, for internal MEMORY
tables, the actual maximum size is determined by
max_heap_table_size
in combination with
tmp_table_size
: Whichever value is smaller is
the one that applies. If the size of an internal
MEMORY
table exceeds the limit, MySQL
automatically converts it to an on-disk
MyISAM
table.
When a new client connects to mysqld, mysqld spawns a new thread to handle the request. This thread first checks whether the hostname is in the hostname cache. If not, the thread attempts to resolve the hostname:
If the operating system supports the thread-safe
gethostbyaddr_r()
and
gethostbyname_r()
calls, the thread uses
them to perform hostname resolution.
If the operating system does not support the thread-safe
calls, the thread locks a mutex and calls
gethostbyaddr()
and
gethostbyname()
instead. In this case, no
other thread can resolve hostnames that are not in the
hostname cache until the first thread unlocks the mutex.
You can disable DNS hostname lookups by starting
mysqld with the
--skip-name-resolve
option. However, in this
case, you can use only IP numbers in the MySQL grant tables.
If you have a very slow DNS and many hosts, you can get more
performance by either disabling DNS lookups with
--skip-name-resolve
or by increasing the
HOST_CACHE_SIZE
define (default value: 128)
and recompiling mysqld.
You can disable the hostname cache by starting the server with
the --skip-host-cache
option. To clear the
hostname cache, issue a FLUSH HOSTS
statement
or execute the mysqladmin flush-hosts
command.
To disallow TCP/IP connections entirely, start
mysqld with the
--skip-networking
option.
Disk seeks are a huge performance bottleneck. This problem becomes more apparent when the amount of data starts to grow so large that effective caching becomes impossible. For large databases where you access data more or less randomly, you can be sure that you need at least one disk seek to read and a couple of disk seeks to write things. To minimize this problem, use disks with low seek times.
Increase the number of available disk spindles (and thereby reduce the seek overhead) by either symlinking files to different disks or striping the disks:
Using symbolic links
This means that, for MyISAM
tables, you
symlink the index file and data files from their usual
location in the data directory to another disk (that may
also be striped). This makes both the seek and read times
better, assuming that the disk is not used for other
purposes as well. See Section 7.6.1, “Using Symbolic Links”.
Striping means that you have many disks and put the first
block on the first disk, the second block on the second
disk, and the N
-th block on the
(
)
disk, and so on. This means if your normal data size is
less than the stripe size (or perfectly aligned), you get
much better performance. Striping is very dependent on the
operating system and the stripe size, so benchmark your
application with different stripe sizes. See
Section 7.1.5, “Using Your Own Benchmarks”.
N
MOD
number_of_disks
The speed difference for striping is very dependent on the parameters. Depending on how you set the striping parameters and number of disks, you may get differences measured in orders of magnitude. You have to choose to optimize for random or sequential access.
For reliability, you may want to use RAID 0+1 (striping plus
mirroring), but in this case, you need 2 ×
N
drives to hold
N
drives of data. This is probably
the best option if you have the money for it. However, you may
also have to invest in some volume-management software to
handle it efficiently.
A good option is to vary the RAID level according to how
critical a type of data is. For example, store semi-important
data that can be regenerated on a RAID 0 disk, but store
really important data such as host information and logs on a
RAID 0+1 or RAID N
disk. RAID
N
can be a problem if you have many
writes, due to the time required to update the parity bits.
On Linux, you can get much more performance by using
hdparm
to configure your disk's interface.
(Up to 100% under load is not uncommon.) The following
hdparm
options should be quite good for
MySQL, and probably for many other applications:
hdparm -m 16 -d 1
Note that performance and reliability when using this command
depend on your hardware, so we strongly suggest that you test
your system thoroughly after using hdparm
.
Please consult the hdparm
manual page for
more information. If hdparm
is not used
wisely, filesystem corruption may result, so back up
everything before experimenting!
You can also set the parameters for the filesystem that the database uses:
If you do not need to know when files were last accessed
(which is not really useful on a database server), you can
mount your filesystems with the -o noatime
option. That skips updates to the last access time in inodes
on the filesystem, which avoids some disk seeks.
On many operating systems, you can set a filesystem to be
updated asynchronously by mounting it with the -o
async
option. If your computer is reasonably stable,
this should give you more performance without sacrificing too
much reliability. (This flag is on by default on Linux.)
You can move tables and databases from the database directory to other locations and replace them with symbolic links to the new locations. You might want to do this, for example, to move a database to a file system with more free space or increase the speed of your system by spreading your tables to different disk.
The recommended way to do this is simply to symlink databases to a different disk. Symlink tables only as a last resort.
On Unix, the way to symlink a database is first to create a directory on some disk where you have free space and then to create a symlink to it from the MySQL data directory.
shell>mkdir /dr1/databases/test
shell>ln -s /dr1/databases/test
/path/to/datadir
MySQL does not support linking one directory to multiple
databases. Replacing a database directory with a symbolic link
works as long as you do not make a symbolic link between
databases. Suppose that you have a database
db1
under the MySQL data directory, and
then make a symlink db2
that points to
db1
:
shell>cd
shell>/path/to/datadir
ln -s db1 db2
The result is that, or any table tbl_a
in
db1
, there also appears to be a table
tbl_a
in db2
. If one
client updates db1.tbl_a
and another client
updates db2.tbl_a
, problems are likely to
occur.
If you really need to do this, you can change one of the
source files. The file to modify depends on your version of
MySQL. For MySQL 4.0 and up, look for the following statement
in the mysys/my_symlink.c
file:
if (!(MyFlags & MY_RESOLVE_LINK) || (!lstat(filename,&stat_buff) && S_ISLNK(stat_buff.st_mode)))
Before MySQL 4.0, look for this statement in the
mysys/mf_format.c
file:
if (flag & 32 || (!lstat(to,&stat_buff) && S_ISLNK(stat_buff.st_mode)))
Change the statement to this:
if (1)
Before MySQL 4.0, you should not symlink tables unless you are
very careful with them. The problem is
that if you run ALTER TABLE
,
REPAIR TABLE
, or OPTIMIZE
TABLE
on a symlinked table, the symlinks are removed
and replaced by the original files. This happens because these
statements work by creating a temporary file in the database
directory and replacing the original file with the temporary
file when the statement operation is complete.
You should not symlink tables on systems that do not have a
fully operational realpath()
call. (Linux
and Solaris support realpath()
). You can
check whether your system supports symbolic links by issuing a
SHOW VARIABLES LIKE 'have_symlink'
statement.
In MySQL 4.0, symlinks are fully supported only for
MyISAM
tables. For files used by tables for
other storage engines, you may get strange problems if you try
to use symbolic links.
The handling of symbolic links for MyISAM
tables in MySQL 4.0 works the following way:
In the data directory, you always have the table format
(.frm
) file, the data
(.MYD
) file, and the index
(.MYI
) file. The data file and index
file can be moved elsewhere and replaced in the data
directory by symlinks. The format file cannot.
You can symlink the data file and the index file independently to different directories.
You can instruct a running MySQL server to perform the
symlinking by using the DATA DIRECTORY
and INDEX DIRECTORY
options to
CREATE TABLE
. See
Section 12.1.5, “CREATE TABLE
Syntax”. Alternatively, symlinking
can be accomplished manually from the command line using
ln -s
if mysqld is
not running.
myisamchk does not replace a symlink
with the data file or index file. It works directly on the
file to which the symlink points. Any temporary files are
created in the directory where the data file or index file
is located. The same is true for the ALTER
TABLE
, OPTIMIZE TABLE
, and
REPAIR TABLE
statements.
When you drop a table that is using symlinks,
both the symlink and the file to which the
symlink points are dropped. This is an
extremely good reason why you should
not run mysqld
as the system root
or allow system
users to have write access to MySQL database
directories.
If you rename a table with ALTER TABLE ...
RENAME
or RENAME TABLE
and
you do not move the table to another database, the
symlinks in the database directory are renamed to the new
names and the data file and index file are renamed
accordingly.
If you use ALTER TABLE ... RENAME
or
RENAME TABLE
to move a table to another
database, the table is moved to the other database
directory. If the table name changed, the symlinks in the
new database directory are renamed to the new names and
the data file and index file are renamed accordingly.
If you are not using symlinks, you should use the
--skip-symbolic-links
option to
mysqld to ensure that no one can use
mysqld to drop or rename a file outside
of the data directory.
SHOW CREATE TABLE
does not report if a
table has symbolic links prior to MySQL 4.0.15. This is also
true for mysqldump, which uses
SHOW CREATE TABLE
to generate
CREATE TABLE
statements.
Table symlink operations that are not supported up through MySQL 4.1:
ALTER TABLE
ignores the DATA
DIRECTORY
and INDEX DIRECTORY
table options.
BACKUP TABLE
and RESTORE
TABLE
do not respect symbolic links.
The .frm
file must
never be a symbolic link (as
indicated previously, only the data and index files can be
symbolic links). Attempting to do this (for example, to
make synonyms) produces incorrect results. Suppose that
you have a database db1
under the MySQL
data directory, a table tbl1
in this
database, and in the db1
directory you
make a symlink tbl2
that points to
tbl1
:
shell>cd
shell>/path/to/datadir
/db1ln -s tbl1.frm tbl2.frm
shell>ln -s tbl1.MYD tbl2.MYD
shell>ln -s tbl1.MYI tbl2.MYI
Problems result if one thread reads
db1.tbl1
and another thread updates
db1.tbl2
:
The query cache is “fooled” (it has no
way of knowing that tbl1
has not
been updated, so it returns outdated results).
ALTER
statements on
tbl2
fail.
Beginning with MySQL 3.23.16, the
mysqld-max and
mysql-max-nt
servers for Windows are
compiled with the -DUSE_SYMDIR
option. This
enables you to put a database directory on a different disk by
setting up a symbolic link to it. This is similar to the way
that symbolic links work on Unix, although the procedure for
setting up the link is different.
It is necessary to define USE_SYMDIR
explicitly only before MySQL 4.0; for
mysqld-max and
mysql-max-nt
, you can enable symbolic links
by using the --symbolic-links
option. As of
MySQL 4.0, symbolic links are enabled by default for all
Windows servers. If you do not need them, you can disable them
with the --skip-symbolic-links
option.
On Windows, create a symbolic link to a MySQL database by
creating a file in the data directory that contains the path
to the destination directory. The file should be named
,
where db_name
.symdb_name
is the database name.
Suppose that the MySQL data directory is
C:\mysql\data
and you want to have
database foo
located at
D:\data\foo
. Set up a symlink using this
procedure:
Make sure that the D:\data\foo
directory exists by creating it if necessary. If you
already have a database directory named
foo
in the data directory, you should
move it to D:\data
. Otherwise, the
symbolic link will be ineffective. To avoid problems, make
sure that the server is not running when you move the
database directory.
Create a text file
C:\mysql\data\foo.sym
that contains
the pathname D:\data\foo\
.
After this, all tables created in the database
foo
are created in
D:\data\foo
.
The following limitations apply to the use of
.sym
files for database symbolic linking
on Windows:
The symbolic link is not used if a directory with the same name as the database exists in the MySQL data directory.
The --innodb_file_per_table
option cannot
be used.