Optimization is a complicated task because it ultimately requires understanding of the whole system. While it may be possible to do some local optimizations with small knowledge of your system/application, the more optimal you want your system to become the more you will have to know about it.
So this chapter will try to explain and give some examples of different ways to optimize MySQL. But remember that there are always some (increasingly harder) additional ways to make the system even faster.
The most important part for getting a system fast is of course the basic design. You also need to know what kinds of things your system will be doing, and what your bottlenecks are.
The most common bottlenecks are:
We start with the system level things since some of these decisions have to be made very early. In other cases a fast look at this part may suffice because it not that important for the big gains. However, it is always nice to have a feeling about how much one could gain by changing things at this level.
The default OS to use is really important! To get the most use of multiple CPU machines one should use Solaris (because the threads works really nice) or Linux (because the 2.2 kernel has really good SMP support). Also on 32-bit machines Linux has a 2G file size limit by default. Hopefully this will be fixed soon when new filesystems are released (XFS/Reiserfs). If you have a desperate need for files bigger than 2G on Linux-intel 32 bit, you should get the LFS patch for the ext2 file system.
Because we have not run MySQL in production on that many platforms, we advice you to test your intended platform before choosing it, if possible.
--skip-lockingMySQL option to avoid external locking. Note that this will not impact MySQL's functionality as long as you only run one server. Just remember to take down the server (or lock relevant parts) before you run
myisamchk. On some system this switch is mandatory because the external locking does not work in any case. The
--skip-lockingoption is on by default when compiling with MIT-pthreads, because
flock()isn't fully supported by MIT-pthreads on all platforms. It's also on default for Linux as Linux file locking are not yet safe. The only case when you can't use
--skip-lockingis if you run multiple MySQL servers (not clients) on the same data, or run
myisamchkon the table without first flushing and locking the
mysqldserver tables first. You can still use
UNLOCK TABLESeven if you are using
Most of the following tests are done on Linux with the MySQL benchmarks, but they should give some indication for other operating systems and workloads.
You get the fastest executable when you link with
On Linux, you will get the fastest code when compiling with
-O3. To compile `sql_yacc.cc' with these options, you
need about 200M memory because
gcc/pgcc needs a lot of memory to
make all functions inline. You should also set
configuring MySQL to avoid inclusion of the
library (it is not needed). Note that with some versions of
the resulting code will only run on true Pentium processors, even if you
use the compiler option that you want the resulting code to be working on
all x586 type processors (like AMD).
By just using a better compiler and/or better compiler options you can get a 10-30 % speed increase in your application. This is particularly important if you compile the SQL server yourself!
We have tested both the Cygnus CodeFusion and Fujitsu compilers, but when we tested them, neither was sufficiently bug free to allow MySQL to be compiled with optimizations on.
When you compile MySQL you should only include support for the
character sets that you are going to use. (Option
The standard MySQL binary distributions are compiled with support
for all character sets.
Here is a list of some measurements that we have done:
pgccand compile everything with
mysqldserver is 1% faster than with
-static), the result is 13% slower on Linux. Note that you still can use a dynamic linked MySQL library. It is only the server that is critical for performance.
strip libexec/mysqld, the resulting binary can be up to 4 % faster.
localhost, MySQL will, by default, use sockets).
--with-debug=full, then you will loose 20 % for most queries, but some queries may take substantially longer (The MySQL benchmarks ran 35 % slower) If you use
--with-debug, then you will only loose 15 %. By starting a
mysqldversion compiled with
--skip-safemallocthe end result should be close to when configuring with
gcc2.95.2 for ultrasparc with the option
-mcpu=v8 -Wa,-xarch=v8plusagives 4 % more performance.
--log-binmakes [MySQL 1 % slower.
The MySQL-Linux distribution provided by MySQL AB used
to be compiled with
pgcc, but we had to go back to regular gcc
because of a bug in
pgcc that would generate the code that does
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 get a faster
binary by compiling with
pgcc. The standard MySQL
Linux binary is linked statically to get it faster and more portable.
hdparm -m 16 -d 1Note that the performance/reliability when using the above depends on your hardware, so we strongly suggest that you test your system thoroughly after using
hdparm! Please consult the
hdparmman page for more information! If
hdparmis not used wisely, filesystem corruption may result. Backup everything before experimenting!
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 may to do this, is to just symlink databases to different disk and only symlink tables as a last resort. .
The way to symlink a database is to first create a directory on some disk where you have free space and then create a symlink to it from the MySQL database directory.
shell> mkdir /dr1/databases/test shell> ln -s /dr1/databases/test mysqld-datadir
MySQL doesn't support that you link one directory to multiple
databases. Replacing a database directory with a symbolic link will
work fine as long as you don't make a symbolic link between databases.
Suppose you have a database
db1 under the MySQL data
directory, and then make a symlink
db2 that points to
shell> cd /path/to/datadir shell> ln -s db1 db2
Now, for any table
db1, there also appears to be
db2. If one thread updates
and another thread updates
db2.tbl_a, there will be problems.
If you really need this, you must change the following code in `mysys/mf_format.c':
if (flag & 32 || (!lstat(to,&stat_buff) && S_ISLNK(stat_buff.st_mode)))
On Windows you can use internal symbolic links to directories by compiling
-DUSE_SYMDIR. This allows you to put different
databases on different disks. See section 4.13.6 Splitting Data Across Different Disks on Windows.
Before MySQL 4.0 you should not symlink tables, if you are not
very carefully with them. The problem is that if you run
REPAIR TABLE or
OPTIMIZE TABLE on a symlinked
table, the symlinks will be removed and replaced by the original
files. This happens because the above command works by creating a
temporary file in the database directory and when the command is
complete, replace the original file with the temporary file.
You should not symlink tables on system that doesn't have a fully
realpath() call. (At least Linux and Solaris support
In MySQL 4.0 symlinks is only fully supported for
tables. For other table types you will probably get strange problems
when doing any of the above mentioned commands.
The handling of symbolic links in MySQL 4.0 works the following
way (this is mostly relevant only for
mysqldis not running) or with the
INDEX/DATA DIRECTORY="path-to-dir"command in
CREATE TABLE. See section 7.7
myisamchkwill not replace a symlink with the index/file but work directly on the files the symlinks points to. Any temporary files will be created in the same directory where the data/index file is.
mysqldas root and not allow persons to have write access to the MySQL database directories.
ALTER TABLE RENAMEand you don't change database, the symlink in the database directory will be renamed to the new name and the data/index file will be renamed accordingly.
ALTER TABLE RENAMEto move a table to another database, then the table will be moved to the other database directory and the old symlinks and the files they pointed to will be deleted.
mysqldto ensure that no one can drop or rename a file outside of the
Things that are not yet supported:
ALTER TABLEignores all
CREATE TABLEdoesn't report if the table has symbolic links.
mysqldumpdoesn't include the symbolic links information in the output.
RESTORE TABLEdoesn't use symbolic links.
You can get the default buffer sizes used by the
with this command:
shell> mysqld --help
This command produces a list of all
mysqld options and configurable
variables. The output includes the default values and looks something
Possible variables for option --set-variable (-O) are: back_log current value: 5 bdb_cache_size current value: 1048540 binlog_cache_size current_value: 32768 connect_timeout current value: 5 delayed_insert_timeout current value: 300 delayed_insert_limit current value: 100 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 lower_case_table_names current value: 0 long_query_time current value: 10 max_allowed_packet current value: 1048576 max_binlog_cache_size current_value: 4294967295 max_connections current value: 100 max_connect_errors current value: 10 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_retry_count current value: 10 net_read_timeout current value: 30 net_write_timeout current value: 60 query_buffer_size current value: 0 record_buffer current value: 131072 slow_launch_time current value: 2 sort_buffer current value: 2097116 table_cache current value: 64 thread_concurrency current value: 10 tmp_table_size current value: 1048576 thread_stack current value: 131072 wait_timeout current value: 28800
If there is a
mysqld server currently running, you can see what
values it actually is using for the variables by executing this command:
shell> mysqladmin variables
You can find a full description for all variables in the
section in this manual. See section 7.28.4
You can also see some statistics from a running server by issuing the command
SHOW STATUS. See section 7.28.3
MySQL uses algorithms that are very scalable, so you can usually run with very little memory. If you, however, give MySQL more memory, you will normally also get better performance.
When tuning a MySQL server, the two most important variables to use
table_cache. You should first feel
confident that you have these right before trying to change any of the
If you have much memory (>=256M) and many tables and want maximum performance with a moderate number of clients, you should use something like this:
shell> safe_mysqld -O key_buffer=64M -O table_cache=256 \ -O sort_buffer=4M -O record_buffer=1M &
If you have only 128M and only a few tables, but you still do a lot of sorting, you can use something like:
shell> safe_mysqld -O key_buffer=16M -O sort_buffer=1M
If you have little memory and lots of connections, use something like this:
shell> safe_mysqld -O key_buffer=512k -O sort_buffer=100k \ -O record_buffer=100k &
shell> safe_mysqld -O key_buffer=512k -O sort_buffer=16k \ -O table_cache=32 -O record_buffer=8k -O net_buffer=1K &
When you have installed MySQL, the `support-files' directory will
contain some different
my.cnf example files, `my-huge.cnf',
`my-large.cnf', `my-medium.cnf', and `my-small.cnf', you can
use as a base to optimize your system.
If there are very many connections, ``swapping problems'' may occur unless
mysqld has been configured to use very little memory for each
mysqld performs better if you have enough memory for all
connections, of course.
Note that if you change an option to
mysqld, it remains in effect only
for that instance of the server.
To see the effects of a parameter change, do something like this:
shell> mysqld -O key_buffer=32m --help
Make sure that the
--help option is last; otherwise, the effect of any
options listed after it on the command line will not be reflected in the
affect the maximum number of files the server keeps open. If you
increase one or both of these values, you may run up against a limit
imposed by your operating system on the per-process number of open file
descriptors. However, you can increase the limit on many systems.
Consult your OS documentation to find out how to do this, because the
method for changing the limit varies widely from system to system.
table_cache is related to
max_connections. For example,
for 200 concurrent running connections, you should have a table cache of
200 * n, where
n is the maximum number of tables
in a join.
The cache of open tables can grow to a maximum of
(default 64; this can be changed with the
mysqld). A table is never closed, except when the
cache is full and another thread tries to open a table or if you use
mysqladmin refresh or
When the table cache fills up, the server uses the following procedure to locate a cache entry to use:
A table is opened for each concurrent access. This means that
if you have two threads accessing the same table or access the table
twice in the same query (with
AS) the table needs to be opened twice.
The first open of any table takes two file descriptors; each additional
use of the table takes only one file descriptor. The extra descriptor
for the first open is used for the index file; this descriptor is shared
among all threads.
You can check if your table cache is too small by checking the mysqld
opened_tables. If this is quite big, even if you
haven't done a lot of
FLUSH TABLES, you should increase your table
cache. See section 7.28.3
If you have many files in a directory, open, close, and create operations will
be slow. If you execute
SELECT statements on many different tables,
there will be 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 making the table cache larger.
When you run
mysqladmin status, you'll see something like this:
Uptime: 426 Running threads: 1 Questions: 11082 Reloads: 1 Open tables: 12
This can be somewhat perplexing if you only have 6 tables.
MySQL is multithreaded, so it may have many queries on the same table simultaneously. To minimize the problem with two threads having different states on the same file, the table is opened independently by each concurrent thread. This takes some memory and one extra file descriptor for the data file. The index file descriptor is shared between all threads.
The list below indicates some of the ways that the
uses memory. Where applicable, the name of the server variable relevant
to the memory use is given:
key_buffer_size) is shared by all threads; Other buffers used by the server are allocated as needed. See section 13.2.4 Tuning Server Parameters.
thread_stack), a connection buffer (variable
net_buffer_length), and a result buffer (variable
net_buffer_length). The connection buffer and result buffer are dynamically enlarged up to
max_allowed_packetwhen needed. When a query is running, a copy of the current query string is also allocated.
BLOBcolumns are stored on disk. One problem in MySQL versions before Version 3.23.2 is that if a HEAP table exceeds the size of
tmp_table_size, you get the error
The table tbl_name is full. In newer versions this is handled by automatically changing the in-memory (HEAP) table to a disk-based (MyISAM) table as necessary. To work around this problem, you can increase the temporary table size by setting the
mysqld, or by setting the SQL option
SQL_BIG_TABLESin the client program. See section 7.33
SETSyntax. In MySQL Version 3.20, the maximum size of the temporary table was
record_buffer*16, so if you are using this version, you have to increase the value of
record_buffer. You can also start
--big-tablesoption to always store temporary tables on disk. However, this will affect the speed of many complicated queries.
3 * nis allocated (where
nis the maximum row length, not counting
BLOBuses 5 to 8 bytes plus the length of the
MyISAMtable handlers will use one extra row buffer for internal usage.
BLOBcolumns, a buffer is enlarged dynamically to read in larger
BLOBvalues. If you scan a table, a buffer as large as the largest
BLOBvalue is allocated.
mysqladmin flush-tablescommand closes all tables that are not in use and marks all in-use tables to be closed when the currently executing thread finishes. This will effectively free most in-use memory.
ps and other system status programs may report that
uses a lot of memory. This may be caused by thread-stacks on different
memory addresses. For example, the Solaris version of
the unused memory between stacks as used memory. You can verify this by
checking available swap with
swap -s. We have tested
mysqld with commercial memory-leakage detectors, so there should
be no memory leaks.
You can find a discussion about different locking methods in the appendix. See section I.4 Locking methods.
All locking in MySQL is deadlock-free. This 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.
The locking method MySQL uses for
WRITE locks works as follows:
The locking method MySQL uses for
READ locks works as follows:
When a lock is released, the lock is made available to the threads in the write lock queue, then to the threads in the read lock queue.
This means that if you have many updates on a table,
statements will wait until there are no more updates.
To work around this for the case where you want to do many
SELECT operations on a table, you can insert rows in a temporary
table and update the real table with the records from the temporary table
once in a while.
This can be done with the following code:
mysql> LOCK TABLES real_table WRITE, insert_table WRITE; mysql> insert into real_table select * from insert_table; mysql> TRUNCATE TABLE insert_table; mysql> UNLOCK TABLES;
You can use the
LOW_PRIORITY options with
SELECT if you want to prioritize retrieval in some specific
cases. You can also start
to get the same behaveour.
SQL_BUFFER_RESULT can also help making table locks shorter.
See section 7.19
You could also 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.
The table locking code in MySQL is deadlock free.
MySQL uses table locking (instead of row locking or column
locking) on all table types, except
BDB tables, to achieve a very
high lock speed. For large tables, table locking is MUCH better than
row locking for most applications, but there are, of course, some
InnoDB tables, MySQL only uses table
locking if you explicitely lock the table with
LOCK TABLES or
execute a command that will modify every row in the table, like
ALTER TABLE. For these table types we recommend you to not use
LOCK TABLES at all.
In MySQL Version 3.23.7 and above, you can insert rows into
MyISAM tables at the same time other threads are reading from the
table. Note that currently this only works if there are no holes after
deleted rows in the table at the time the insert is made. When all holes
has been filled with new data, concurrent inserts will automatically be
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 will wait until the update is ready.
As updates on tables normally are considered to be more important than
SELECT, all statements that update a table have higher priority
than statements that retrieve information from a table. This should
ensure that updates are not 'starved' because one issues a lot of heavy
queries against a specific table. (You can change this by using
LOW_PRIORITY with the statement that does the update or
HIGH_PRIORITY with the
Starting from MySQL Version 3.23.7 one can use the
max_write_lock_count variable to force MySQL to
temporary give all
SELECT statements, that wait for a table, a
higher priority after a specific number of inserts on a table.
Table locking is, however, not very good under the following senario:
SELECTthat takes a long time to run.
UPDATEon a used table. This client will wait until the
SELECTstatement on the same table. As
UPDATEhas higher priority than
SELECTwill wait for the
UPDATEto finish. It will also wait for the first
full disk, in which case all threads that wants to access the problem table will also be put in a waiting state until more disk space is made available.
Some possible solutions to this problem are:
SELECTstatements to run faster. You may have to create some summary tables to do this.
--low-priority-updates. This will give all statements that update (modify) a table lower priority than a
SELECTstatement. In this case the last
SELECTstatement in the previous scenario would execute before the
DELETEstatement lower priority with the
mysqldwith a low value for max_write_lock_count to give
READlocks after a certain number of
SET SQL_LOW_PRIORITY_UPDATES=1. See section 7.33
SELECTis very important with the
HIGH_PRIORITYattribute. See section 7.19
SELECT, switch to use the new
MyISAMtables as these support concurrent
INSERTwill probably solve your problems. See section 7.21
DELETEmay help. See section 7.17
When a new thread connects to
mysqld will span a
new thread to handle the request. This thread will first check if the
hostname is in the hostname cache. If not the thread will call
gethostbyname_r() to resolve the
If the operating system doesn't support the above thread-safe calls, the
thread will lock a mutex and call
gethostbyname() instead. Note that in this case no other thread
can resolve other hostnames that is not in the hostname cache until the
first thread is ready.
You can disable DNS host lookup by starting
--skip-name-resolve. In this case you can however only use IP
names in the MySQL privilege tables.
If you have a very slow DNS and many hosts, you can get more performance by
either disabling DNS lookop with
--skip-name-resolve or by
HOST_CACHE_SIZE define (default: 128) and recompile
You can disable the hostname cache with
can clear the hostname cache with
FLUSH HOSTS or
If you don't want to allow connections over
TCP/IP, you can do this
One of the most basic optimization is to get your data (and indexes) to take as little space on the disk (and in memory) as possible. This can give huge improvements because disk reads are faster and normally less main memory will be used. Indexing also takes less resources if done on smaller columns.
MySQL supports a lot of different table types and row formats. Choosing the right table format may give you a big performance gain. See section 8 MySQL Table Types.
You can get better performance on a table and minimize storage space using the techniques listed below:
MEDIUMINTis often better than
NOT NULLif possible. It makes everything faster and you save one bit per column. Note that if you really need
NULLin your application you should definitely use it. Just avoid having it on all columns by default.
BLOBcolumns), a fixed-size record format is used. This is faster but unfortunately may waste some space. See section 8.1.2 MyISAM Table Formats.
Indexes are used to find rows with a specific value of one column fast. Without an index MySQL has to start with the first record and then read through the whole table until it finds the relevant rows. The bigger the table, the more this costs. If the table has an index for the columns in question, MySQL can quickly get a position to seek to in the middle of the data file without having to look at all the data. If a table has 1000 rows, this is at least 100 times faster than reading sequentially. Note that if you need to access almost all 1000 rows it is faster to read sequentially because we then avoid disk seeks.
All MySQL indexes (
INDEX) are stored in B-trees. Strings are automatically prefix-
and end-space compressed. See section 7.36
CREATE INDEX Syntax.
Indexes are used to:
MIN()value for a specific indexed column. This is optimized by a preprocessor that checks if you are using
WHEREkey_part_# = constant on all key parts < N. In this case MySQL will do a single key lookup and replace the
MIN()expression with a constant. If all expressions are replaced with constants, the query will return at once:
SELECT MIN(key_part2),MAX(key_part2) FROM table_name where key_part1=10
ORDER BY key_part_1,key_part_2). The key is read in reverse order if all key parts are followed by
DESC. The index can also be used even if the
ORDER BYdoesn't match the index exactly, as long as all the unused index parts and all the extra are
ORDER BYcolumns are constants in the
WHEREclause. The following queries will use the index to resolve the
SELECT * FROM foo ORDER BY key_part1,key_part2,key_part3; SELECT * FROM foo WHERE column=constant ORDER BY column, key_part1; SELECT * FROM foo WHERE key_part1=const GROUP BY key_part2;
SELECT key_part3 FROM table_name WHERE key_part1=1
Suppose you issue the following
mysql> SELECT * FROM tbl_name WHERE col1=val1 AND col2=val2;
If a multiple-column index exists on
appropriate rows can be fetched directly. If separate single-column
indexes exist on
col2, the optimizer tries to
find the most restrictive index by deciding which index will find 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
MySQL can't use a partial index if the columns don't form a
leftmost prefix of the index. Suppose you have the
statements shown below:
mysql> SELECT * FROM tbl_name WHERE col1=val1; mysql> SELECT * FROM tbl_name WHERE col2=val2; mysql> SELECT * FROM tbl_name WHERE col2=val2 AND col3=val3;
If an index exists on
(col1,col2,col3), only the first query
shown above uses the index. The second and third queries do involve
indexed columns, but
(col2,col3) are not
leftmost prefixes of
MySQL also uses indexes for
LIKE comparisons if the argument
LIKE is a constant string that doesn't start with a wild-card
character. For example, the following
SELECT statements use indexes:
mysql> select * from tbl_name where key_col LIKE "Patrick%"; mysql> select * from tbl_name where key_col LIKE "Pat%_ck%";
In the first statement, only rows with
"Patrick" <= key_col <
"Patricl" are considered. In the second statement, only rows with
"Pat" <= key_col < "Pau" are considered.
SELECT statements will not use indexes:
mysql> select * from tbl_name where key_col LIKE "%Patrick%"; mysql> select * from tbl_name where key_col LIKE other_col;
In the first statement, the
LIKE value begins with a wild-card
character. In the second statement, the
LIKE value is not a
column_name IS NULL will use indexes if column_name
is an index.
MySQL normally uses the index that finds the least number of rows. An
index is used for columns that you compare with the following operators:
BETWEEN, and a
LIKE with a non-wild-card prefix like
Any index that doesn't span all
AND levels in the
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
WHERE clauses use indexes:
... WHERE index_part1=1 AND index_part2=2 AND other_column=3 ... WHERE index=1 OR A=10 AND index=2 /* index = 1 OR index = 2 */ ... WHERE index_part1='hello' AND index_part_3=5 /* optimized like "index_part1='hello'" */ ... WHERE index1=1 and index2=2 or index1=3 and index3=3; /* Can use index on index1 but not on index2 or index 3 */
WHERE clauses do NOT use indexes:
... WHERE index_part2=1 AND index_part3=2 /* index_part_1 is not used */ ... WHERE index=1 OR A=10 /* Index is not used in both AND parts */ ... WHERE index_part1=1 OR index_part2=10 /* No index spans all rows */
Note that in some cases MySQL will not use an index, even if one would be available. Some of the cases where this happens are:
LIMITto only retrieve part of the rows, MySQL will use an index anyway, as it can much more quickly find the few rows to return in the result.
First, one thing that affects all queries: The more complex permission system setup you have, the more overhead you get.
If you do not have any
GRANT statements done, MySQL will
optimize the permission checking somewhat. So if you have a very high
volume it may be worth the time to avoid grants. Otherwise more
permission check results in a larger overhead.
If your problem is with some explicit MySQL function, you can always time this in the MySQL client:
mysql> select benchmark(1000000,1+1); +------------------------+ | benchmark(1000000,1+1) | +------------------------+ | 0 | +------------------------+ 1 row in set (0.32 sec)
The above shows that MySQL can execute 1,000,000
expressions in 0.32 seconds on a
All MySQL functions should be very optimized, but there may be
some exceptions, and the
benchmark(loop_count,expression) is a
great tool to find out if this is a problem with your query.
In most cases you can estimate the performance by counting disk seeks.
For small tables, you can usually find the row in 1 disk seek (as the
index is probably cached). For bigger tables, you can estimate that
(using B++ tree indexes) you will need:
log(index_block_length / 3 * 2 / (index_length + data_pointer_length)) +
1 seeks to find a row.
In MySQL an index block is usually 1024 bytes and the data
pointer is usually 4 bytes. A 500,000 row table with an
index length of 3 (medium integer) gives you:
log(500,000)/log(1024/3*2/(3+4)) + 1 = 4 seeks.
As the above index would require about 500,000 * 7 * 3/2 = 5.2M, (assuming that the index buffers are filled to 2/3, which is typical) you will probably have much of the index in memory and you will probably only need 1-2 calls to read data from the OS to find the row.
For writes, however, you will need 4 seek requests (as above) to find where to place the new index and normally 2 seeks to update the index and write the row.
Note that the above doesn't mean that your application will slowly degenerate by N log N! As long as everything is cached by the OS or SQL server things will only go marginally slower while the table gets bigger. After the data gets too big to be cached, things will start to go much slower until your applications is only bound by disk-seeks (which increase by N log N). To avoid this, increase the index cache as the data grows. See section 13.2.4 Tuning Server Parameters.
In general, when you want to make a slow
SELECT ... WHERE faster, the
first thing to check is whether or not you can add an index. See section 13.4 How MySQL Uses Indexes. All references between different tables
should usually be done with indexes. You can use the
to determine which indexes are used for a
See section 7.29
EXPLAIN Syntax (Get Information About a
Some general tips:
myisamchk --analyzeon a table after it has been loaded with relevant 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, of course.). MySQL will use this to decide which index to choose when you connect two tables with 'a non-constant expression'. You can check the result from the
analyzerun by doing
SHOW INDEX FROM table_nameand examining the
myisamchk --sort-index --sort-records=1(if you want to sort on index 1). If you have a unique index from which you want to read all records in order according to that index, this is a good way to make that faster. Note, however, that this sorting isn't written optimally and will take a long time for a large table!
WHERE optimizations are put in the
SELECT part here because
they are mostly used with
SELECT, but the same optimizations apply for
Also note that this section is incomplete. MySQL does many optimizations, and we have not had time to document them all.
Some of the optimizations performed by MySQL are listed below:
((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)
(a<b AND b=c) AND a=5 -> b>5 AND b=c AND a=5
(B>=5 AND B=5) OR (B=6 AND 5=5) OR (B=7 AND 5=6) -> B=5 OR B=6
COUNT(*)on a single table without a
WHEREis retrieved directly from the table information. This is also done for any
NOT NULLexpression when used with only one table.
SELECTstatements are impossible and returns no rows.
HAVINGis merged with
WHEREif you don't use
GROUP BYor group functions (
WHEREis constructed to get a fast
WHEREevaluation for each sub-join and also to skip records as soon as possible.
WHEREclause on a
UNIQUEindex, or a
PRIMARY KEY, where all index parts are used with constant expressions and the index parts are defined as
mysql> SELECT * FROM t WHERE primary_key=1; mysql> SELECT * FROM t1,t2 WHERE t1.primary_key=1 AND t2.primary_key=t1.id;
ORDER BYand in
GROUP BYcome from the same table, then this table is preferred first when joining.
ORDER BYclause and a different
GROUP BYclause, or if the
GROUP BYcontains columns from tables other than the first table in the join queue, a temporary table is created.
SQL_SMALL_RESULT, MySQL will use an in-memory temporary table.
HAVINGclause are skipped.
Some examples of queries that are very fast:
mysql> SELECT COUNT(*) FROM tbl_name; mysql> SELECT MIN(key_part1),MAX(key_part1) FROM tbl_name; mysql> SELECT MAX(key_part2) FROM tbl_name WHERE key_part_1=constant; mysql> SELECT ... FROM tbl_name ORDER BY key_part1,key_part2,... LIMIT 10; mysql> SELECT ... FROM tbl_name ORDER BY key_part1 DESC,key_part2 DESC,... LIMIT 10;
The following queries are resolved using only the index tree (assuming the indexed columns are numeric):
mysql> SELECT key_part1,key_part2 FROM tbl_name WHERE key_part1=val; mysql> SELECT COUNT(*) FROM tbl_name WHERE key_part1=val1 AND key_part2=val2; mysql> SELECT key_part2 FROM tbl_name GROUP BY key_part1;
The following queries use indexing to retrieve the rows in sorted order without a separate sorting pass:
mysql> SELECT ... FROM tbl_name ORDER BY key_part1,key_part2,... ; mysql> SELECT ... FROM tbl_name ORDER BY key_part1 DESC,key_part2 DESC,... ;
DISTINCT is converted to a
GROUP BY on all columns,
DISTINCT combined with
ORDER BY will in many cases also
need a temporary table.
LIMIT # with
DISTINCT, MySQL will stop
as soon as it finds
# unique rows.
If you don't use columns from all used tables, MySQL will stop the scanning of the not used tables as soon as it has found the first match.
SELECT DISTINCT t1.a FROM t1,t2 where t1.a=t2.a;
In the case, assuming t1 is used before t2 (check with
MySQL will stop reading from t2 (for that particular row in t1)
when the first row in t2 is found.
A LEFT JOIN B in MySQL is implemented as follows:
Bis set to be dependent on table
Aand all tables that
Ais dependent on.
Ais set to be dependent on all tables (except
B) that are used in the
LEFT JOINconditions are moved to the
WHEREoptimizations are done.
Athat matches the
WHEREclause, but there wasn't any row in
Bthat matched the
LEFT JOINcondition, then an extra
Brow is generated with all columns set to
LEFT JOINto find rows that don't exist in some table and you have the following test:
column_name IS NULLin the
WHEREpart, where column_name is a column that is declared as
NOT NULL, then MySQL will stop searching after more rows (for a particular key combination) after it has found one row that matches the
RIGHT JOIN is implemented analogously as
The table read order forced by
LEFT JOIN and
will help the join optimizer (which calculates in which order tables
should be joined) to do its work much more quickly, as there are fewer
table permutations to check.
Note that the above means that if you do a query of type:
SELECT * FROM a,b LEFT JOIN c ON (c.key=a.key) LEFT JOIN d (d.key=a.key) WHERE b.key=d.key
MySQL will do a full scan on
b as the
JOIN will force it to be read before
The fix in this case is to change the query to:
SELECT * FROM b,a LEFT JOIN c ON (c.key=a.key) LEFT JOIN d (d.key=a.key) WHERE b.key=d.key
In some cases MySQL will handle the query differently when you are
LIMIT # and not using
LIMIT, MySQL will use indexes in some cases when it normally would prefer to do a full table scan.
ORDER BY, MySQL will end the sorting as soon as it has found the first
#lines instead of sorting the whole table.
DISTINCT, MySQL will stop as soon as it finds
GROUP BYcan be resolved by reading the key in order (or do a sort on the key) and then calculate summaries until the key value changes. In this case
LIMIT #will not calculate any unnecessary
#rows to the client, it will abort the query.
LIMIT 0will always quickly return an empty set. This is useful to check the query and to get the column types of the result columns.
LIMIT #to calculate how much space is needed to resolve the query.
The time to insert a record consists approximately of:
where the numbers are somewhat proportional to the overall time. 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 N log N (B-trees).
Some ways to speed up inserts:
INSERTstatements. This is much faster (many times in some cases) than using separate
INSERT DELAYEDstatement. See section 7.21
MyISAMyou can insert rows at the same time
SELECTs are running if there are no deleted rows in the tables.
LOAD DATA INFILE. This is usually 20 times faster than using a lot of
INSERTstatements. See section 7.23
LOAD DATA INFILESyntax.
LOAD DATA INFILErun even faster when the table has many indexes. Use the following procedure:
CREATE TABLE. For example, using
FLUSH TABLESstatement or the shell command
myisamchk --keys-used=0 -rq /path/to/db/tbl_name. This will remove all usage of all indexes from the table.
LOAD DATA INFILE. This will not update any indexes and will therefore be very fast.
myisampackon it to make it smaller. See section 220.127.116.11 Compressed Table Characteristics.
myisamchk -r -q /path/to/db/tbl_name. This will create the index tree in memory before writing it to disk, which is much faster because it avoids lots of disk seeks. The resulting index tree is also perfectly balanced.
FLUSH TABLESstatement or the shell command
LOAD DATA INFILEin some future version of MySQL.
mysql> LOCK TABLES a WRITE; mysql> INSERT INTO a VALUES (1,23),(2,34),(4,33); mysql> INSERT INTO a VALUES (8,26),(6,29); mysql> UNLOCK TABLES;The main speed difference is that the index buffer is flushed to disk only once, after all
INSERTstatements have completed. Normally there would be as many index buffer flushes as there are different
INSERTstatements. Locking is not needed if you can insert all rows with a single statement. Locking will also lower the total time of multi-connection tests, but the maximum wait time for some threads will go up (because they wait for locks). For example:
thread 1 does 1000 inserts thread 2, 3, and 4 does 1 insert thread 5 does 1000 insertsIf you don't use locking, 2, 3, and 4 will finish before 1 and 5. If you use locking, 2, 3, and 4 probably will not finish before 1 or 5, but the total time should be about 40% faster. As
DELETEoperations are very fast in MySQL, you will obtain better overall performance by adding locks around everything that does more than about 5 inserts or updates in a row. If you do very many inserts in a row, you could do a
LOCK TABLESfollowed by an
UNLOCK TABLESonce in a while (about each 1000 rows) to allow other threads access to the table. This would still result in a nice performance gain. Of course,
LOAD DATA INFILEis much faster for loading data.
To get some more speed for both
LOAD DATA INFILE and
INSERT, enlarge the key buffer. See section 13.2.4 Tuning Server Parameters.
Update queries are optimized as a
SELECT query with the additional
overhead of a write. The speed of the write is dependent on the size of
the data that is being updated and the number of indexes that are
updated. Indexes that are not changed will not be updated.
Also, another way to get fast updates is to delay updates and then do many updates in a row later. Doing many updates in a row is much quicker than doing one at a time if you lock the table.
Note that, with dynamic record format, updating a record to
a longer total length may split the record. So if you do this often,
it is very important to
OPTIMIZE TABLE sometimes.
See section 7.11
OPTIMIZE TABLE Syntax.
If you want to delete all rows in the table, you should use
TRUNCATE TABLE table_name. See section 7.18
The time to delete a record is exactly proportional to the number of indexes. To delete records more quickly, you can increase the size of the index cache. See section 13.2.4 Tuning Server Parameters.
Unsorted tips for faster systems:
thread_cache_sizevariable. See section 13.2.4 Tuning Server Parameters.
EXPLAINcommand. See section 7.29
EXPLAINSyntax (Get Information About a
SELECTqueries on tables that are updated a lot. This is to avoid problems with table locking.
MyISAMtables can insert rows in a table without deleted rows at the same time another table is reading from it. If this is important for you, you should consider methods where you don't have to delete rows or run
OPTIMIZE TABLEafter you have deleted a lot of rows.
ALTER TABLE ... ORDER BY expr1,expr2...if you mostly retrieve rows in expr1,expr2.. order. By using this option after big changes to the table, you may be able to get higher performance.
SELECT * FROM table_name WHERE hash=MD5(concat(col1,col2)) AND col_1='constant' AND col_2='constant'
BLOBcolumns. You will get dynamic row length as soon as you are using a single
BLOBcolumn. See section 8 MySQL Table Types.
UPDATE table set count=count+1 where index_column=constantis very fast! This is really important when you use databases like MySQL that only have table locking (multiple readers / single writers). This will also give better performance with most databases, as the row locking manager in this case will have less to do.
INSERT /*! DELAYED */when you do not need to know when your data is written. This speeds things up because many records can be written with a single disk write.
INSERT /*! LOW_PRIORITY */when you want your selects to be more important.
SELECT /*! HIGH_PRIORITY */to get selects that jump the queue. That is, the select is done even if there is somebody waiting to do a write.
INSERTstatement to store many rows with one SQL command (many SQL servers supports this).
LOAD DATA INFILEto load bigger amounts of data. This is faster than normal inserts and will be even faster when
myisamchkis integrated in
AUTO_INCREMENTcolumns to make unique values.
OPTIMIZE TABLEonce in a while to avoid fragmentation when using dynamic table format. See section 7.11
HEAPtables to get more speed when possible. See section 8 MySQL Table Types.
customer_namein the customer table). To make your names portable to other SQL servers you should keep them shorter than 18 characters.
MyISAMdirectly, you could get a speed increase of 2-5 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 the above problems by introducing low-level
MyISAMcommands 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 types of optimization.
DELAY_KEY_WRITE=1will make the updating of indexes faster, as these are not logged to disk until the file is closed. The downside is that you should run
myisamchkon these tables before you start
mysqldto ensure that they are okay if something killed
mysqldin the middle. As the key information can always be generated from the data, you should not lose anything by using
You should definitely benchmark your application and database to find out where the bottlenecks are. By fixing it (or by replacing the bottleneck with a 'dummy module') you can then easily identify the next bottleneck (and so on). Even if the overall performance for your application is sufficient, 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 an example of portable benchmark programs, look at the MySQL benchmark suite. See section 14 The MySQL Benchmark Suite. You can take any program from this suite and modify it for your needs. By doing this, you can try different solutions to your problem and test which is really the fastest solution for you.
It is very common that some problems only occur 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 every one of these cases so far, it has been problems with basic design (table scans are NOT good at high load) or OS/Library issues. Most of this would be a LOT 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 Sasha's recent hack for this - super-smack. As the name suggests, it can bring your system down to its knees if you ask it, so make sure to use it only on your development systems.
MySQL keeps row data and index data in separate files. Many (almost all) other databases 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 will cause 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 (like in Oracle/Sybase et al). In this case you will 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:
Because MySQL uses extremely fast table locking (multiple readers / single writers) the biggest remaining problem is a mix of a steady stream of inserts and slow selects on the same table.
We believe that for a huge number of systems the extremely fast performance in other cases make this choice a win. This case is usually also possible to solve by having multiple copies of the table, but it takes more effort and hardware.
We are also working on some extensions to solve this problem for some common application niches.
Because all SQL servers implement different parts of SQL, it takes work to write portable SQL applications. For very simple selects/inserts it is very easy, but the more you need the harder it gets. If you want an application that is fast with many databases it becomes even harder!
To make a complex application portable you need to choose a number of SQL servers that it should work with.
You can use the MySQL crash-me program/web-page http://www.mysql.com/information/crash-me.php to find functions, types, and limits you can use with a selection of database servers. Crash-me now tests far from everything possible, but it is still comprehensive with about 450 things tested.
For example, you shouldn't have column names longer than 18 characters if you want to be able to use Informix or DB2.
Both the MySQL benchmarks and crash-me programs are very database-independent. By taking a look at how we have handled this, you can get a feeling for what you have to do to write your application database-independent. The benchmarks themselves can be found in the `sql-bench' directory in the MySQL source distribution. They are written in Perl with DBI database interface (which solves the access part of the problem).
See http://www.mysql.com/information/benchmarks.html for the results from this benchmark.
As you can see in these results, all databases have some weak points. That is, they have different design compromises that lead to different behavior.
If you strive for database independence, you need to get a good feeling for each SQL server's bottlenecks. MySQL is VERY fast in retrieving and updating things, but will have a problem in mixing slow readers/writers on the same table. Oracle, on the other hand, has a big problem when you try to access rows that you have recently updated (until they are flushed to disk). Transaction databases in general are not very good at generating summary tables from log tables, as in this case row locking is almost useless.
To get your application really database-independent, you need to define an easy extendable interface through which you manipulate your data. As C++ is available on most systems, it makes sense to use a C++ classes interface to the databases.
If you use some specific feature for some database (like the
REPLACE command in MySQL), you should code a method for
the other SQL servers to implement the same feature (but slower). With
MySQL you can use the
/*! */ syntax to add
MySQL-specific keywords to a query. The code inside
/**/ will be treated as a comment (ignored) by most other SQL
If REAL high performance is more important than exactness, as in some Web applications, a possibility is 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 is quite nice in case of extremely high load, in which case you can dynamically increase the cache and set the expire timeout higher until things get back to normal.
In this case the table creation information should contain information of the initial size of the cache and how often the table should normally be refreshed.
During MySQL initial development, the features of MySQL were made to fit our largest customer. They handle data warehousing for a couple of the biggest retailers in Sweden.
From all stores, we get weekly summaries of all bonus card transactions, and we are expected to provide useful information for the store owners to help them find how their advertisement campaigns are affecting their customers.
The data is quite huge (about 7 million summary transactions per month), and we have data for 4-10 years that we need to present to the users. We got weekly requests from the customers that they want to get 'instant' access to new reports from this data.
We solved this by storing all information per month in compressed 'transaction' tables. We have a set of simple macros (script) that generates summary tables grouped by different criteria (product group, customer id, store ...) from the transaction tables. The reports are Web pages that are dynamically generated by a small Perl script that parses a Web page, executes the SQL statements in it, and inserts the results. We would have used PHP or mod_perl instead but they were not available at that time.
For graphical data we wrote a simple tool in
C that can produce
GIFs based on the result of a SQL query (with some processing of the
result). This is also dynamically executed from the Perl script that
In most cases a new report can simply be done by copying an existing script and modifying the SQL query in it. In some cases, we will need to add more fields to an existing summary table or generate a new one, but this is also quite simple, as we keep all transactions tables on disk. (Currently we have at least 50G of transactions tables and 200G of other customer data.)
We also let our customers access the summary tables directly with ODBC so that the advanced users can themselves experiment with the data.
We haven't had any problems handling this with quite modest Sun Ultra SPARCstation (2x200 Mhz). We recently upgraded one of our servers to a 2 CPU 400 Mhz UltraSPARC, and we are now planning to start handling transactions on the product level, which would mean a ten-fold increase of data. We think we can keep up with this by just adding more disk to our systems.
We are also experimenting with Intel-Linux to be able to get more CPU power cheaper. Now that we have the binary portable database format (new in Version 3.23), we will start to use this for some parts of the application.
Our initial feelings are that Linux will perform much better on low-to-medium load and Solaris will perform better when you start to get a high load because of extreme disk IO, but we don't yet have anything conclusive about this. After some discussion with a Linux Kernel developer, this might be a side effect of Linux giving so much resources to the batch job that the interactive performance gets very low. This makes the machine feel very slow and unresponsive while big batches are going. Hopefully this will be better handled in future Linux Kernels.
Go to the first, previous, next, last section, table of contents.