Optimization is a complicated task since 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) ways to make the system even faster left to do.
The most important part for getting a system fast is of course the basic design. You also need to know that kinds of things your system will be doing. That is your bottlenecks are.
The most common bottlenecks are.
We start with the system level things sine some of these decisions have to be made very early. In other cases a fast look at this part may suffice since it not that important for the big gains. But it is always nice to have a feeling about how much one gould gain by chancing 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 32bit machines Linux has a 2G file size limit by default. Hopefully this will be fixed soon when new filesystems is released (XFS).
Since we have not run production MySQL on that many platforms we advice you to test your intended platform before choosing it if possible.
Other tips:
--skip-locking MySQL option to avoid external
locking. Note that this will not impact MySQL functionality as
long that 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 since the external locking does not work in any
case.
The --skip-locking option is on by default when compiling with
MIT-pthreads, because flock() isn't fully supported by
MIT-pthreads on all platforms.
The only case when you can't use --skip-locking is if you run
multiple MySQL SERVERS (not clients) on the same data. Or run
myisamchk on the table without first flushing and locking the
mysqld server tables first.
You can still use LOCK TABLES / UNLOCK TABLES even if you
are using --skip-locking
Most of the following tests are done on Linux and 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 -static. Using Unix
sockets rather than TCP/IP to connect to a database also gives better
performance.
On Linux, you will get the fastest code when compiling with pgcc
and -O6. 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 CXX=gcc when
configuring MySQL to avoid inclusion of the libstdc++
library (it is not needed).
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 yourselves!
On Intel you should for example use pgcc or the Cygnus CodeFusion compiler to get maximum speed. We have tested the new Fujitsu compiler but it is not yet bug free enough to compile MySQL with optimizations on.
Here is a list of some mesurements that we have done:
pgcc and compile everything with -O6, the
mysqld server is 11% faster than with gcc versions
older than gcc 2.95.2.
-static), the result is 13%
slower. Note that you still can use a dynamic linked MySQL library. It
is only the server that is critical for performance.
gcc 2.7.3 is 13% faster than Sun Pro C++ 4.2.
The MySQL-Linux distribution provided by TcX is compiled with
pgcc and linked statically.
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.
If MySQL notices that a table is a symbolically-linked, it will
resolve the symlink and use the table it points to instead. This works
on all systems that support the realpath() call (at least Linux
and Solaris support realpath())! On systems that don't support
realpath(), you should not access the table through the real path
and through the symlink at the same time! If you do, the table will be
inconsistent after any update.
MySQL doesn't support linking of databases by default. Things
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 db1:
shell> cd /path/to/datadir shell> ln -s db1 db2
Now, for any table tbl_a in db1, there also appears to be
a table tbl_a in db2. If one thread updates db1.tbl_a
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 (!lstat(to,&stat_buff)) /* Check if it's a symbolic link */
if (S_ISLNK(stat_buff.st_mode) && realpath(to,buff))
Change the code to this:
if (realpath(to,buff))
You can get the default buffer sizes used by the mysqld server
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
like this:
Possible variables for option --set-variable (-O) are: back_log current value: 5 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_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 net_buffer_length current value: 16384 query_buffer_size current value: 0 record_buffer current value: 131072 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
Each option is described below. Values for buffer sizes, lengths and stack
sizes are given in bytes. You can specify values with a suffix of `K'
or `M' to indicate kilobytes or megabytes. For example, 16M
indicates 16 megabytes. Case of suffix letters does not matter;
16M and 16m are equivalent.
You can also see some statistics from a running server by the command
SHOW STATUS. See section 7.21 SHOW syntax (Get information about tables, columns,...).
ansi_mode.ON if mysqld was started with --ansi.
See section 5.2 Runnning MySQL in ANSI mode.
back_logback_log value indicates how many requests can be
stacked during this short time before MySQL momentarily stops
answering new requests. You need to increase this only if you expect a large
number of connections in a short period of time.
In other words, this value is the size of the listen queue for incoming
TCP/IP connections. Your operating system has its own limit on the size
of this queue. The manual page for the Unix listen(2) system
call should have more details. Check your OS documentation for the
maximum value for this variable. Attempting to set back_log
higher than your operating system limit will be ineffective.
concurrent_insertsON (the default), MySQL will allow you to use INSERT
on MyISAM tables at the same time as you run SELECT queries
on them. You can turn this option off by starting mysqld with --safe
or --skip-new.
connect_timeoutmysqld server is waiting for a connect
packet before responding with Bad handshake.
delayed_insert_timeoutINSERT DELAYED thread should wait for INSERT
statements before terminating.
delayed_insert_limitdelayed_insert_limit rows, the INSERT
DELAYED handler will check if there are any SELECT statements
pending. If so, it allows these to execute before continuing.
delay_key_writedelay_key_write option CREATE TABLE. This means that the
key buffer for tables with this option will not get flushed on every
index update, but only when a table is closed. This will speed up
writes on keys a lot but you should add automatic checking of all tables
with myisamchk --fast --force if you use this. Note that if you
start mysqld with the --delay-key-write-for-all-tables
option this means that all tables will be treated as if they were
created with the delay_key_write option. You can clear this flag
by starting mysqld with --skip-new or --safe-mode.
delayed_queue_sizeINSERT
DELAYED. If the queue becomes full, any client that does INSERT
DELAYED will wait until there is room in the queue again.
flush_timeflush_time seconds all
tables will be closed (to free up resources and sync things to disk).
init_file--init-file option when
you start the server. This is a file of SQL statements you want the
server to execute when it starts.
interactive_timeoutCLIENT_INTERACTIVE option to
mysql_real_connect(). See also wait_timeout.
join_buffer_sizekey_buffer_sizekey_buffer_size is the size of the buffer used for index blocks.
Increase this get better index handling (for all reads and multiple
writes) to as much as you can afford; 64M on a 256M machine that mainly
runs MySQL is quite common. If you however make this too big
(more than 50% of your total memory?) your system may start to page
and become REAL slow. Remember that since MySQL does not cache data
read that you will have to leave some room for the OS filesystem cache.
You can check the performance of the key buffer by doing show
status and examine the variables Key_read_requests,
Key_reads, Key_write_requests and Key_writes. The
Key_reads/Key_read_request ratio should normally be < 0.01.
The Key_write/Key_write_requests is usually near 1 if you are
using mostly updates/deletes but may be much smaller if you tend to
do updates that affect many at the same time or if you are
using delay_key_write. See section 7.21 SHOW syntax (Get information about tables, columns,...).
To get even more speed when writing many rows at the same time use
LOCK TABLES. See section 7.24 LOCK TABLES/UNLOCK TABLES syntax.
lower_case_table_nameslong_query_timeSlow_queries counter
will be incremented.
max_allowed_packetnet_buffer_length bytes, but can grow up to max_allowed_packet
bytes when needed. This value by default is small to catch big (possibly
wrong) packets. You must increase this value if you are using big
BLOB columns. It should be as big as the biggest BLOB you want
to use.
max_connectionsmysqld requires. See below for
comments on file descriptor limits. See section 19.2.4 Too many connections error.
max_connect_errorsFLUSH HOSTS.
max_delayed_threadsINSERT DELAYED
statements. If you try to insert data in a new table after all INSERT
DELAYED threads are in use, the row will be inserted as if the
DELAYED attribute wasn't specified.
max_join_sizemax_join_size
records return an error. Set this value if your users tend to perform joins
without a WHERE clause that take a long time and return
millions of rows.
max_heap_table_sizemax_sort_lengthBLOB or TEXT
values (only the first max_sort_length bytes of each value
are used; the rest are ignored).
max_tmp_tablesmax_write_lock_countnet_buffer_lengthmax_allowed_packet bytes.)
net_retry_countFreeBSD as
internal interrupts is sent to all threads.
record_bufferquery_buffer_sizeskip_show_databasesSHOW DATABASES, if they don't
have the PROCESS_PRIV privilege. This can improve security if
you're concerned about people being able to see what databases and
tables other users have.
sort_bufferORDER BY or GROUP BY
operations.
See section 19.5 Where MySQL stores temporary files.
table_cachemysqld requires.
MySQL needs two file descriptors for each unique open table.
See below for comments on file descriptor limits. You can check if you
need to increase the table cache by checking the Opened_tables
variable. See section 7.21 SHOW syntax (Get information about tables, columns,...). If this variable is big and you don't do
FLUSH TABLES a lot (which just forces all tables to be closed and
reopenend), then you should increase the value of this variable.
For information about how the table cache works, see section 11.2.4 How MySQL opens and closes tables.
tmp_table_sizeThe table tbl_name is full. Increase the value of
tmp_table_size if you do many advanced GROUP BY queries.
thread_concurrencymysqld will call thr_setconcurrency() with
this value. thr_setconcurrency() permits the application to give
the threads system a hint, for the desired number of threads that should
be run at the same time.
thread_stackcrash-me test are dependent on this value. The default is
large enough for normal operation. See section 11.7 Using your own benchmarks.
wait_timeoutinteractive_timeout.
MySQL uses algorithms that are very scalable, so you can usually run with very little memory or give MySQL more memory to get better performance.
When tunning a MySQL server, the two most important variables to use are
key_buffer and table_cache. You should first feel
confident that you have got these right before trying to change any of
the other variables.
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 &
or even:
shell> safe_mysqld -O key_buffer=512k -O sort_buffer=16k \
-O table_cache=32 -O record_buffer=8k -O net_buffer=1K &
If there are very many 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, 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
output.
table_cache, max_connections and max_tmp_tables
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 open connections, you should have a table cache of
at least 200 * n, where n is the maximum number of tables in
a join.
The cache of open tables can grow to a maximum of table_cache
(default 64; this can be changed with with the -O table_cache=#
option to 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 mysqladmin flush-tables.
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.
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 mysqld server
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 11.2.3 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_packet when needed. When
a query is running a copy of the current query string is also allocated.
record_buffer).
BLOB columns are
stored on disk.
One problem in MySQL versions before 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 tmp_table_size
option to mysqld, or by setting the SQL option
SQL_BIG_TABLES in the client program. See section 7.25 SET syntax. In MySQL 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 mysqld with the --big-tables option to always
store temporary tables on disk, however, this will affect the speed of
many complicated queries.
malloc() and
free()).
3 * n is
allocated (where n is the maximum row length, not counting BLOB
columns). A BLOB uses 5 to 8 bytes plus the length of the BLOB
data.
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.
mysqladmin flush-tables command 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 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 have tested mysqld with commercial
memory-leakage detectors, so there should be no memory leaks.
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, SELECT
statements will wait until there are no more updates.
To work around this for the case where you want to do many INSERT and
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> delete from insert_table; mysql> UNLOCK TABLES;
You can use the LOW_PRIORITY options with INSERT if you
want to prioritize retrieval in some specific cases. See section 7.14 INSERT syntax.
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) to achieve a very high lock speed. For large tables, table locking is for most applications MUCH better than row locking, but there are of course some pitfalls.
In MySQL 3.23.7 and above, you can insert rows into
MyISAM tables at the same time as other threads are reading from
the table. Note that currently this only works if there are no deleted
rows in the table.
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 others threads that want to access this particular table will wait until the update is ready.
As updates of databases 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.
Starting from MySQL 3.23.7 one can use the
max_write_lock_count variable to force MySQL to issue
a SELECT after a specific number of inserts on a table.
One main problem with this is the following:
SELECT that takes a long time to run.
UPDATE on a used table; This client
will wait until the SELECT is finished
SELECT statement on the same table; As
UPDATE has higher priority than SELECT, this SELECT
will wait for the UPDATE to finish. It will also wait for the first
SELECT to finish!
Some possible solutions to this problem are:
SELECT statements to run faster; You may have to create
some summary tables to do this.
mysqld with --low-priority-updates. This will give
all statements that update (modify) a table lower priority than a SELECT
statement. In this case the last SELECT statement in the previous
scenario would execute before the INSERT statement.
INSERT,UPDATE or DELETE statement
lower priority with the LOW_PRIORITY attribute.
mysqld with a low value for max_write_lock_count to give
READ locks after a certain number of WRITE locks.
SET SQL_LOW_PRIORITY_UPDATES=1.
See section 7.25 SET syntax.
SELECT is very important with the
HIGH_PRIORITY attribute. See section 7.12 SELECT syntax.
INSERT combined with SELECT,
switch to use the new MyISAM tables as these supports concurrent
SELECTs and INSERTs.
INSERT and SELECT statements, the
DELAYED attribute to INSERT will probably solve your problems.
See section 7.14 INSERT syntax.
SELECT and DELETE, the LIMIT
option to DELETE may help. See section 7.11 DELETE syntax.
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 since disk reads are faster and normally less main memory will also 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:
MEDIUMINT is often better than INT.
NOT NULL if possible. It makes everything
faster and you save one bit per column. Note that if you really need
NULL in your application you should definitely use it. Just avoid
haveing it on all columns by default.
VARCHAR,
TEXT or BLOB columns), 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 find a row with a specific calue on one column fast. Without a index MySQL has to start with the first record and then read through the whole table until it find the relevent rows. The bigger the table the more this costs. If the table has a index for the colums in question MySQL can get fast a possition to seek to in the middle of the data file without having to look at all data. If a table have 1000 rows this is at least 100 times faster than reading sequentially. Note that is you need to access almost all 1000 rows it is faster to read sequentially since we when avoid disk seeks.
All MySQL indexes (PRIMARY, UNIQUE and INDEX) are
stored in B-trees. Strings are automatically prefix- and end-space
compressed. See section 7.27 CREATE INDEX syntax.
Indexes are used to:
WHERE clause.
MAX() or MIN() value for a specific indexed
column.
ORDER BY key_part_1,key_part_2 ). The
key is read in reverse order if all key parts are followed by DESC.
Suppose 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 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 (col1), (col1,col2) and
(col1,col2,col3).
MySQL can't use a partial index if the columns don't form a
leftmost prefix of the index. Suppose you have the SELECT
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) and (col2,col3) are not
leftmost prefixes of (col1,col2,col3).
MySQL also uses indexes for LIKE comparisons if the argument
to LIKE is a constant string that doesn't start with a wildcard
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.
The following 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 wildcard character.
In the second statement, the LIKE value is not a constant.
Searching using column_name IS NULL will use indexes if column_name
is a index.
MySQL normally uses the index that finds least number of rows. An
index is used for columns that you compare with the following operators:
=, >, >=, <, <=, BETWEEN and a
LIKE with a non-wildcard prefix like 'something%'.
Any index that doesn't 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:
... 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 */
These 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 */
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 PentiumII 400MHz.
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 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(row_count) /
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, which gives for a 500,000 row table with a
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 you will however 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 11.2.3 Tuning server parameters.
SELECT queries
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 11.4 MySQL index use. All references between different tables
should usually be done with indexes. You can use the EXPLAIN
command to determine which indexes are used for a SELECT.
See section 7.22 EXPLAIN syntax (Get information about a SELECT).
Some general tips:
myisamchk
--analyze on 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 not constant expression'.
You can check the result from the analyze run by doing SHOW
INDEX FROM table_name and examining the Cardinality column.
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 clauses
The where optimizes are put in the SELECT part here since they
are mostly used there. But the same optimizations are used for there in
DELETE and UPDATE statements.
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 WHERE is retrieved
directly from the table information. This is also done for any NOT NULL
expression when used with only one table.
SELECT statements are impossible and returns no rows.
HAVING is merged with WHERE if you don't use GROUP
BY or group functions (COUNT(), MIN()...)
WHERE is constructed to get a fast
WHERE evaluation for each sub join and also to skip records as
soon as possible.
WHERE clause on a UNIQUE
index, or a PRIMARY KEY, where all index parts are used with constant
expressions and the index parts are defined as NOT NULL.
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 BY and in GROUP
BY come from the same table, then this table is preferred first when
joining.
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.
SQL_SMALL_RESULT, MySQL will use an in-memory
temporary table.
DISTINCT is converted to a GROUP BY on all columns,
DISTINCT combined with ORDER BY will in many cases also need
a temporary table.
HAVING clause
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,...
LEFT JOIN
A LEFT JOIN B is in MySQL implemented as follows
B is set to be dependent on table A and all tables
that A is dependent on.
A is set to be dependent on all tables (except B)
that are used in the LEFT JOIN condition.
LEFT JOIN conditions are moved to the WHERE clause.
WHERE optimzations are done.
A that matches the WHERE clause, but there
wasn't any row in B that matched the LEFT JOIN condition,
then an extra B row is generated with all columns set to NULL.
LEFT JOIN to find rows that doesn't exist in some
table and you have the following test: column_name IS NULL in the
WHERE part, 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 LEFT JOIN condition.
The table read order forced by LEFT JOIN and STRAIGHT JOIN will help
the join optimizer (which calculates in which order tables should be joined) to do
its work much 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
Then MySQL will do a full scan on b as the LEFT JOIN will
force it to be read before d.
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
LIMIT
In some cases MySQL will handle the query differently when you are
using LIMIT # and not using HAVING:
LIMIT, MySQL
will use indexes in some cases when it normally would prefer to do a
full table scan.
LIMIT # with ORDER BY, MySQL will end the
sorting as soon as it has found the first # lines instead of sorting
the whole table.
LIMIT # with DISTINCT, MySQL will stop
as soon as it finds # unique rows.
GROUP BY can 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 GROUP's.
# rows to the client, it
will abort the query.
LIMIT 0 will 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.
INSERT queriesThe 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:
INSERT statements. This is much faster (many
times in some cases) than using separate INSERT statements.
INSERT DELAYED statement. See section 7.14 INSERT syntax.
MyISAM you 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 INSERT statements.
See section 7.16 LOAD DATA INFILE syntax.
LOAD DATA INFILE run even
faster when the table has many indexes. Use the following procedure:
CREATE TABLE. For example using
mysql or Perl-DBI.
FLUSH TABLES statement or the shell command mysqladmin
flush-tables.
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.
myisampack and want to compress the table, run
myisampack on it. See section 8.1.2.3 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 since it avoid lots of disk
seeks. The resulting index tree is also perfectly balanced.
FLUSH TABLES statement or the shell command mysqladmin
flush-tables.
LOAD DATA INFILE in 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
INSERT statements have completed. Normally there would
be as many index buffer flushes as there are different INSERT
statements. 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
INSERT, UPDATE and DELETE operations 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 TABLES followed by a UNLOCK TABLES once 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 INFILE is much faster still for loading data.
To get some more speed for both LOAD DATA INFILE and
INSERT, enlarge the key buffer. See section 11.2.3 Tuning server parameters.
UPDATE queries
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 are 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.
Not that with dynamic record format updating a record with 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.9 OPTIMIZE TABLE syntax.
DELETE queriesThe 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 11.2.3 Tuning server parameters.
Its also much faster to remove all rows than to remove a big part of the rows from a table.
Unsorted tips for faster systems:
EXPLAIN
command. See section 7.22 EXPLAIN syntax (Get information about a SELECT).
SELECT queries on tables that are updated a
lot. This is to avoid problems with table locking.
MyISAM tables 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 TABLE after you have deleted a lot of rows.
SELECT * from table where hash='calculated hash on col1 and col2'
and col_1='constant' and col_2='constant' and ..
VARCHAR
or BLOB columns. You will get dynamic row length as soon as you
are using a single VARCHAR or BLOB columns. See section 8 MySQL table types.
UPDATE table set count=count+1 where index_column=constant
is very fast!
This is really important when you use databases like MySQL that
only has 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 now when your
data is written. This speeds things up since many records can be written
with a single disk write.
INSERT /*! LOW_PRIORITY */ when you want your selects are
more important.
SELECT /*! HIGH_PRIORITY */ to get selects that jumps the
queue. That is the select is done even if there is somebody waiting to
do a write.
INSERT statement to store many rows with one
SQL command (many SQL servers supports this)
LOAD DATA INFILE to load bigger amounts of data. This if
faster than normal inserts and will be even faster when myisamchk
is integrated in mysqld.
AUTO_INCREMENT columns to make unique values.
OPTIMIZE TABLE once in a while to avoid fragmentation when
using dynamic table format.See section 7.9 OPTIMIZE TABLE syntax.
HEAP tables to get more speed when possibe. See section 8 MySQL table types.
name instead of
customer_name in the customer table). To make your names portable
to other SQL servers you should keep them shorter than 18 characters.
MyISAM directly you could
get a speed increase of 2-5 times compared to using the SQL interface.
The be able to do this the data must however be on the same server as
the application and usually it should only be accessed by on processes
(because external file locking is real slow). One could eliminate the
above 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 types of optimisations.
DELAY_KEY_WRITE=1 will 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 myisamchk on these tables before
you start mysqld to ensure that they are ok if something killed
mysqld in the middle. As the key information can always be generated
from the data you should not lose anything by using DELAY_KEY_WRITE.
You should definitely benchmark your application and database to find out where is the bottlenecks. 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 'good enough' you should at least make a 'plan', for each bottleneck, how to solve it if you someday 'really need it fix it'.
For some example portable becnchmark programs look at the MySQL benchmark suite. See section 12 The MySQL benchmark suite. You can take any program 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 then the system is very heavily loaded. And we have had many customer who contacts us then they have a (tested) system in production and have have got load problems. In every on 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 system where not already in production.
To avoid probles like this you should put some effort into benchmarking your whole appliction under the worst possible load!
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 belive 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 get a performance hit for every query that access more than one column. Since this degenerates so quickly when more that when one columns are accessed we believe that this model is not good for general purpose databases.
The more common case is there the index and data are stored together (like in Oracle/Sybase at all). 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 (depends on how well the index is cached) saves a disk read. The bad things with this layout is:
Since 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 extension to solve this problem for some common application niches.
Since 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. And if you want a 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 server that it should work with.
When you can use the MySQL crash-me program/web-page http://www.mysql.com/crash-me-choose.htmy to find functions, types and limits you can use with a selection of database servers. Crash-me now test a long way from everything possible but it still is vīcomprehensive with about 450 things tested.
For example, you shouldn't have longer column names 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 of how we have handled this, you can get a feeling of what you have to do to write your application database independent. The benchmark 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/benchmark.html the results from this benchmark.
As you can see in these results all databases has 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 of each SQL servers 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 in 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 a 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
servers.
If REAL high performance is more important than exactness, like in some web applications. A possibility is to create a application layer that caches all results to give you even higher performance. By just letting old results 'expire' after a while you can keep the cache reasonable fresh. This is quite nice in case of extremely high load, in which case you can dynamically increase the cache to be bigger and set the expire timeout higher until things gets back to normal.
In this case the table creating 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 where made to fit our largest customer. They handle data warehousing for a couple of the biggest retailers in Sweden.
We get from all stores 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 advertisements 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 generate summary tables grouped by different criterias (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 pages, executes the SQL statements in it and inserts the results. Now we would have used PHP or mod_perl instead but they where 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
parses the HTML files.
In most cases a new report can simple by done by copying a 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 simply 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 Mz). We recently upgrade one of our servers to a 2 CPU 400 Mz Ultra sparc and we are now planing to start handling transactions on the product level, which would mean a 10 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 3.32) 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 but Solaris will perform better when you start to get a a high load because of extrema 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 make 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.