|
|
The MySQL (R) software delivers a very fast, multi-threaded, multi-user, and robust SQL (Structured Query Language) database server. MySQL Server is intended for mission-critical, heavy-load production systems as well as for embedding into mass-deployed software. MySQL is a registered trademark of MySQL AB.
The MySQL software is Dual Licensed. Users can choose to use the MySQL software as an Open Source product under the terms of the GNU General Public License (http://www.fsf.org/licenses/) or can purchase a standard commercial license from MySQL AB. See http://www.mysql.com/company/legal/licensing/ for more information on our licensing policies.
The following list describes some sections of particular interest in this manual:
Important:
Reports of errors (often called ``bugs''), as well as questions and comments, should be sent to http://bugs.mysql.com. See section 1.4.1.3 How to Report Bugs or Problems.
If you have found a sensitive security bug in MySQL Server, please let us know immediately by sending an email message to security@mysql.com.
This is the Reference Manual for the MySQL Database System. It documents MySQL up to Version 4.1.10a, but is also applicable for older versions of the MySQL software (such as 3.23 or 4.0-production) because functional changes are indicated with reference to a version number.
Because this manual serves as a reference, it does not provide general instruction on SQL or relational database concepts. It also will not teach you how to use your operating system or command-line interpreter.
The MySQL Database Software is under constant development, and the Reference Manual is updated frequently as well. The most recent version of the manual is available online in searchable form at http://dev.mysql.com/doc/. Other formats also are available, including HTML, PDF, and Windows CHM versions.
The primary document is the Texinfo file.
The HTML version is produced automatically using a modified version of
texi2html.
The plain text and Info versions are produced with makeinfo.
The PostScript version is produced using texi2dvi and dvips.
The PDF version is produced with pdftex.
If you have any suggestions concerning additions or corrections to this manual, please send them to the documentation team at docs@mysql.com.
This manual was initially written by David Axmark and Michael ``Monty'' Widenius. It is maintained by the MySQL Documentation Team, consisting of Paul DuBois, Stefan Hinz, Mike Hillyer, Jon Stephens, and Russell Dyer. For the many other contributors, see section B Credits.
The copyright (2004) to this manual is owned by the Swedish company MySQL AB. MySQL and the MySQL logo are (registered) trademarks of MySQL AB. Other trademarks and registered trademarks referred to in this manual are the property of their respective owners, and are used for identification purposes only.
This manual uses certain typographical conventions:
constant
mysqladmin works, invoke it with the
--help option.''
When commands are shown that are meant to be executed from within a particular
program, the program is indicated by a prompt shown before the command. For
example, shell> indicates a command that you execute from your login
shell, and mysql> indicates a statement that you execute from the
mysql client program:
shell> type a shell command here mysql> type a mysql statement here
The ``shell'' is your command interpreter. On Unix, this is typically a
program such as sh or csh. On Windows, the equivalent program is
command.com or cmd.exe, typically run in a console window.
When you enter a command or statement shown in an example, do not type the prompt shown in the example.
Database, table, and column names must often be substituted into statements. To indicate that such substitution is necessary, this manual uses db_name, tbl_name, and col_name. For example, you might see a statement like this:
mysql> SELECT col_name FROM db_name.tbl_name;
This means that if you were to enter a similar statement, you would supply your own database, table, and column names, perhaps like this:
mysql> SELECT author_name FROM biblio_db.author_list;
SQL keywords are not case sensitive and may be written in uppercase or lowercase. This manual uses uppercase.
In syntax descriptions, square brackets (`[' and `]') are used
to indicate optional words or clauses. For example, in the following
statement, IF EXISTS is optional:
DROP TABLE [IF EXISTS] tbl_name
When a syntax element consists of a number of alternatives, the alternatives are separated by vertical bars (`|'). When one member from a set of choices may be chosen, the alternatives are listed within square brackets (`[' and `]'):
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
When one member from a set of choices must be chosen, the alternatives are listed within braces (`{' and `}'):
{DESCRIBE | DESC} tbl_name [col_name | wild]
An ellipsis (...) indicates the omission of a section of a statement,
typically to provide a shorter version of more complex syntax. For example,
INSERT ... SELECT is shorthand for the form of INSERT statement
that is followed by a SELECT statement.
An ellipsis can also indicate that the preceding syntax element of a statement may be repeated. In the following example, multiple reset_option values may be given, with each of those after the first preceded by commas:
RESET reset_option [,reset_option] ...
Commands for setting shell variables are shown using Bourne shell syntax. For example, the sequence to set an environment variable and run a command looks like this in Bourne shell syntax:
shell> VARNAME=value some_command
If you are using csh or tcsh, you must issue commands somewhat
differently. You would execute the sequence just shown like this:
shell> setenv VARNAME value shell> some_command
MySQL, the most popular Open Source SQL database management system, is developed, distributed, and supported by MySQL AB. MySQL AB is a commercial company, founded by the MySQL developers. It is a second generation Open Source company that unites Open Source values and methodology with a successful business model.
The MySQL Web site (http://www.mysql.com/) provides the latest information about MySQL software and MySQL AB.
The official way to pronounce ``MySQL'' is ``My Ess Que Ell'' (not ``my sequel''), but we don't mind if you pronounce it as ``my sequel'' or in some other localized way.
We started out with the intention of using mSQL to connect to our
tables using our own fast low-level (ISAM) routines. However, after some
testing, we came to the conclusion that mSQL was not fast enough or
flexible enough for our needs. This resulted in a new SQL interface to our
database but with almost the same API interface as mSQL. This API was
designed to allow third-party code that was written for use with mSQL to
be ported easily for use with MySQL.
The derivation of the name MySQL is not clear. Our base directory and a large number of our libraries and tools have had the prefix ``my'' for well over 10 years. However, co-founder Monty Widenius's daughter is also named My. Which of the two gave its name to MySQL is still a mystery, even for us.
The name of the MySQL Dolphin (our logo) is ``Sakila,'' which was chosen by the founders of MySQL AB from a huge list of names suggested by users in our ``Name the Dolphin'' contest. The winning name was submitted by Ambrose Twebaze, an Open Source software developer from Swaziland, Africa. According to Ambrose, the name Sakila has its roots in SiSwati, the local language of Swaziland. Sakila is also the name of a town in Arusha, Tanzania, near Ambrose's country of origin, Uganda.
The following list describes some of the important characteristics of the MySQL Database Software. See also section 1.3 MySQL Development Roadmap for more information about current and upcoming features.
MyISAM) with index compression.
FLOAT, DOUBLE, CHAR, VARCHAR,
TEXT, BLOB, DATE, TIME, DATETIME,
TIMESTAMP, YEAR, SET, ENUM, and OpenGIS spatial
types.
See section 11 Column Types.
SELECT and WHERE
clauses of queries. For example:
mysql> SELECT CONCAT(first_name, ' ', last_name)
-> FROM citizen
-> WHERE income/dependents > 10000 AND age > 30;
GROUP BY and
ORDER BY clauses. Support
for group functions (COUNT(),
COUNT(DISTINCT ...),
AVG(), STD(),
SUM(), MAX(), MIN(), and GROUP_CONCAT()).
LEFT OUTER JOIN and RIGHT OUTER JOIN with both standard
SQL and ODBC syntax.
DELETE, INSERT, REPLACE, and UPDATE return
the number of rows that were changed (affected). It is possible to return
the number of rows matched instead by setting a flag when connecting to the
server.
SHOW command can be used to retrieve
information about databases, tables, and indexes. The EXPLAIN command
can be used to determine how the optimizer resolves a query.
ABS is a valid column name. The only restriction is that for a
function call, no spaces are allowed between the function name and the
`(' that follows it. See section 9.6 Treatment of Reserved Words in MySQL.
CHAR, VARCHAR,
BLOB, or TEXT column types.
--shared-memory option. Clients can
connect through shared memory by using the --protocol=memory option.
latin1 (ISO-8859-1), german, big5, ujis,
and more. For example,
the Scandinavian characters `â', `ä' and `ö' are
allowed in table and column names.
Unicode support is available as of MySQL 4.1.
mysqlcheck client. MySQL also includes
myisamchk, a very fast command-line utility for performing these
operations on MyISAM tables.
See section 5 Database Administration.
--help or -?
options to obtain online assistance.
This section addresses the questions, ``How stable is MySQL Server?'' and, ``Can I depend on MySQL Server in this project?'' We will try to clarify these issues and answer some important questions that concern many potential users. The information in this section is based on data gathered from the mailing lists, which are very active in identifying problems as well as reporting types of use.
The original code stems back to the early 1980s. It provides a stable code
base, and the ISAM table format used by the original storage engine
remains backward-compatible.
At TcX, the predecessor of MySQL AB, MySQL code has worked
in projects since mid-1996, without any problems.
When the MySQL Database Software initially was released to a wider public,
our new users quickly found some pieces of untested code. Each new release
since then has had fewer portability problems, even though each new release
has also had many new features.
Each release of the MySQL Server has been usable. Problems have occurred only when users try code from the ``gray zones.'' Naturally, new users don't know what the gray zones are; this section therefore attempts to document those areas that are currently known. The descriptions mostly deal with Version 3.23, 4.0 and 4.1 of MySQL Server. All known and reported bugs are fixed in the latest version, with the exception of those listed in the bugs section, which are design-related. See section 1.5.7 Known Errors and Design Deficiencies in MySQL.
The MySQL Server design is multi-layered with independent modules. Some of the newer modules are listed here with an indication of how well-tested each of them is:
InnoDB tables (Stable)
InnoDB transactional storage engine has been declared
stable in the MySQL 3.23 tree, starting from version 3.23.49.
InnoDB is being used in large, heavy-load production systems.
BDB tables (Stable)
Berkeley DB code is very stable, but we are still improving
the BDB transactional storage engine interface in MySQL Server.
MyODBC 3.51 (Stable)
MyODBC 3.51 uses ODBC SDK 3.51 and is in wide production use.
Some issues brought up appear to be application-related and independent of
the ODBC driver or underlying database server.
MySQL 3.22 had a 4GB (4 gigabyte) limit on table size. With the
MyISAM storage engine in MySQL 3.23, the maximum table
size was increased to 8 million terabytes (2 ^ 63 bytes). With this larger
allowed table size, the maximum effective table size for MySQL
databases is usually determined by operating system constraints
on file sizes, not by MySQL internal limits.
The InnoDB storage engine maintains InnoDB tables within a
tablespace that can be created from several files. This allows a
table to exceed the maximum individual file size. The tablespace can include
raw disk partitions, which allows extremely large tables. The maximum
tablespace size is 64TB.
The following table lists some examples of operating system file-size limits. This is only a rough guide and is not intended to be definitive. For the most up-to-date information, be sure to check the documentation specific to your operating system.
| Operating System | File-size Limit |
| Linux 2.2-Intel 32-bit | 2GB (LFS: 4GB) |
| Linux 2.4 | (using ext3 filesystem) 4TB |
| Solaris 9/10 | 16TB |
| NetWare w/NSS filesystem | 8TB |
| win32 w/ FAT/FAT32 | 2GB/4GB |
| win32 w/ NTFS | 2TB (possibly larger) |
| MacOS X w/ HFS+ | 2TB |
On Linux 2.2, you can get MyISAM tables larger than 2GB in size by
using the Large File Support (LFS) patch for the ext2 filesystem. On Linux
2.4, patches also exist for ReiserFS to get support for big files (up to 2TB). Most
current Linux distributions are based on kernel 2.4 and include all
the required LFS patches. With JFS and XFS, petabyte and larger files
are possible on Linux. However, the maximum available file size still depends
on several factors, one of them being the filesystem used to store MySQL tables.
For a detailed overview about LFS in Linux, have a look at Andreas Jaeger's Large File Support in Linux page at http://www.suse.de/~aj/linux_lfs.html.
Windows users please note: FAT and VFAT (FAT32) are not considered suitable for production use with MySQL. Use NTFS instead.
By default, MySQL creates MyISAM tables with an internal
structure that allows a maximum size of about 4GB. You can
check the maximum table size for a table with the SHOW TABLE STATUS
statement or with myisamchk -dv tbl_name.
See section 13.5.4 SHOW Syntax.
If you need a MyISAM table that will be larger than 4GB in size (and your
operating system supports large files), the CREATE TABLE statement
allows AVG_ROW_LENGTH and MAX_ROWS options.
See section 13.2.6 CREATE TABLE Syntax.
You can also change these options with ALTER TABLE after the table has
been created, to increase the table's maximum allowable size.
See section 13.2.2 ALTER TABLE Syntax.
Other ways to work around file-size limits for MyISAM tables are as
follows:
myisampack to
compress it. myisampack usually compresses a table by at
least 50%, so you can have, in effect, much bigger tables.
myisampack also can merge multiple tables into a single table.
See section 8.2 myisampack, the MySQL Compressed Read-only Table Generator.
MyISAM
data files is by using the RAID options.
See section 13.2.6 CREATE TABLE Syntax.
MERGE library that allows
you to handle a collection of MyISAM tables that have identical
structure as a single MERGE table.
See section 14.2 The MERGE Storage Engine.
The MySQL Server itself has no problems with Year 2000 (Y2K) compliance:
2037 for TIMESTAMP values. For DATE and DATETIME
values, dates through the year 9999 are accepted.
YEAR column type
can store years 0 and 1901 to 2155 in one byte and
display them using two or four digits.
All two-digit years are considered to be in the range
1970 to 2069, which means that if you store 01 in a
YEAR column, MySQL Server treats it as 2001.
The following simple demonstration illustrates that MySQL Server
has no problems with DATE or DATETIME values through the year
9999, and no problems with TIMESTAMP values until after the year 2030:
mysql> DROP TABLE IF EXISTS y2k;
Query OK, 0 rows affected (0.01 sec)
mysql> CREATE TABLE y2k (date DATE,
-> date_time DATETIME,
-> time_stamp TIMESTAMP);
Query OK, 0 rows affected (0.01 sec)
mysql> INSERT INTO y2k VALUES
-> ('1998-12-31','1998-12-31 23:59:59',19981231235959),
-> ('1999-01-01','1999-01-01 00:00:00',19990101000000),
-> ('1999-09-09','1999-09-09 23:59:59',19990909235959),
-> ('2000-01-01','2000-01-01 00:00:00',20000101000000),
-> ('2000-02-28','2000-02-28 00:00:00',20000228000000),
-> ('2000-02-29','2000-02-29 00:00:00',20000229000000),
-> ('2000-03-01','2000-03-01 00:00:00',20000301000000),
-> ('2000-12-31','2000-12-31 23:59:59',20001231235959),
-> ('2001-01-01','2001-01-01 00:00:00',20010101000000),
-> ('2004-12-31','2004-12-31 23:59:59',20041231235959),
-> ('2005-01-01','2005-01-01 00:00:00',20050101000000),
-> ('2030-01-01','2030-01-01 00:00:00',20300101000000),
-> ('2040-01-01','2040-01-01 00:00:00',20400101000000),
-> ('9999-12-31','9999-12-31 23:59:59',99991231235959);
Query OK, 14 rows affected (0.01 sec)
Records: 14 Duplicates: 0 Warnings: 2
mysql> SELECT * FROM y2k;
+------------+---------------------+----------------+
| date | date_time | time_stamp |
+------------+---------------------+----------------+
| 1998-12-31 | 1998-12-31 23:59:59 | 19981231235959 |
| 1999-01-01 | 1999-01-01 00:00:00 | 19990101000000 |
| 1999-09-09 | 1999-09-09 23:59:59 | 19990909235959 |
| 2000-01-01 | 2000-01-01 00:00:00 | 20000101000000 |
| 2000-02-28 | 2000-02-28 00:00:00 | 20000228000000 |
| 2000-02-29 | 2000-02-29 00:00:00 | 20000229000000 |
| 2000-03-01 | 2000-03-01 00:00:00 | 20000301000000 |
| 2000-12-31 | 2000-12-31 23:59:59 | 20001231235959 |
| 2001-01-01 | 2001-01-01 00:00:00 | 20010101000000 |
| 2004-12-31 | 2004-12-31 23:59:59 | 20041231235959 |
| 2005-01-01 | 2005-01-01 00:00:00 | 20050101000000 |
| 2030-01-01 | 2030-01-01 00:00:00 | 20300101000000 |
| 2040-01-01 | 2040-01-01 00:00:00 | 00000000000000 |
| 9999-12-31 | 9999-12-31 23:59:59 | 00000000000000 |
+------------+---------------------+----------------+
14 rows in set (0.00 sec)
The final two TIMESTAMP column values are zero because the
year values (2040, 9999) exceed the TIMESTAMP maximum. The
TIMESTAMP data type, which is used to store the current time,
supports values that range from 19700101000000 to
20300101000000 on 32-bit machines (signed value). On 64-bit
machines, TIMESTAMP handles values up to 2106 (unsigned
value).
Although MySQL Server itself is Y2K-safe, you may run into
problems if you use it with applications that are not Y2K-safe.
For example, many old applications store or manipulate years using
two-digit values (which are ambiguous) rather than four-digit values.
This problem may be compounded by applications that use
values such as 00 or 99 as ``missing'' value indicators.
Unfortunately, these problems may be difficult to fix because different
applications may be written by different programmers, each of whom may
use a different set of conventions and date-handling functions.
Thus, even though MySQL Server has no Y2K problems, it is the application's responsibility to provide unambiguous input. See section 11.3.4 Y2K Issues and Date Types for MySQL Server's rules for dealing with ambiguous date input data that contains two-digit year values.
This section provides a snapshot of the MySQL development roadmap, including major features implemented or planned for MySQL 4.0, 4.1, 5.0, and 5.1. The following sections provide information for each release series.
The current production release series is MySQL 4.1, which was declared stable for production use as of Version 4.1.7, released in October 2004. The previous production release series is MySQL 4.0, which was declared stable for production use as of Version 4.0.12, released in March 2003. Production status means that future 4.1 and 4.0 development is limited only to bugfixes. For the older MySQL 3.23 series, only critical bugfixes are made.
Active MySQL development currently is taking place in the MySQL 5.0 release series, this means that new features are being added there. MySQL 5.0 is available in alpha status.
Before upgrading from one release series to the next, please see the notes at section 2.10 Upgrading MySQL.
Plans for some of the most requested features are summarized in the following table.
| Feature | MySQL Series |
| Unions | 4.0 |
| Subqueries | 4.1 |
| R-trees | 4.1 (for MyISAM tables)
|
| Stored procedures | 5.0 |
| Views | 5.0 |
| Cursors | 5.0 |
| Foreign keys | 5.1 (implemented in 3.23 for InnoDB)
|
| Triggers | 5.0 and 5.1 |
| Full outer join | 5.1 |
| Constraints | 5.1 |
MySQL Server 4.0 is available in production status.
MySQL 4.0 is available for download at http://dev.mysql.com/ and from our mirrors. MySQL 4.0 has been tested by a large number of users and is in production use at many large sites.
The major new features of MySQL Server 4.0 are geared toward our existing business and community users, enhancing the MySQL database software as the solution for mission-critical, heavy-load database systems. Other new features target the users of embedded databases.
INSERT statements, searching on
packed indexes, full-text searching (using FULLTEXT indexes), and
COUNT(DISTINCT).
InnoDB storage engine as standard
InnoDB storage engine is offered as a standard feature of the
MySQL server. This means full support for ACID transactions, foreign
keys with cascading UPDATE and DELETE, and row-level locking
are standard features.
See section 15 The InnoDB Storage Engine.
FULLTEXT search properties of MySQL Server 4.0 enables
FULLTEXT indexing of large text masses with both binary
and natural-language searching logic. You can customize minimal word
length and define your own stop word lists in any human language,
enabling a new set of applications to be built with MySQL Server.
See section 12.6 Full-Text Search Functions.
UNION statement, a standard SQL feature.
TRUNCATE TABLE (as in Oracle).
latin1_de, which ensures that the
German sorting order sorts words with umlauts in the same order
as do German telephone books.
mysqld parameters (startup options) can be set without taking
down the server. This is a convenient feature for database administrators
(DBAs).
See section 13.5.3 SET Syntax.
DELETE and UPDATE statements have been added.
MyISAM storage engine supports symbolic
linking at the table level (and not just the database level as before).
SQL_CALC_FOUND_ROWS and FOUND_ROWS() are new functions that make it
possible to find out the number of rows a SELECT query that includes a
LIMIT clause would have returned without that clause.
The news section of this manual includes a more in-depth list of features. See section D.3 Changes in release 4.0.x (Production).
The libmysqld embedded server library makes MySQL Server suitable for
a vastly expanded realm of applications. By using this library, developers can
embed MySQL Server into various applications and electronics devices, where
the end user has no knowledge of there actually being an underlying
database. Embedded MySQL Server is ideal for use behind
the scenes in Internet appliances, public kiosks, turnkey
hardware/software combination units, high performance Internet
servers, self-contained databases distributed on CD-ROM, and so on.
Many users of libmysqld will benefit from the MySQL
Dual Licensing. For those not wishing to be bound by the GPL,
the software is also made available under a commercial license.
See http://www.mysql.com/company/legal/licensing/ for more information
on the licensing policy of MySQL AB.
The embedded MySQL library uses the same interface as the normal
client library, so it is convenient and easy to use.
See section 22.2.16 libmysqld, the Embedded MySQL Server Library.
On Windows there are two different libraries:
libmysqld.lib | Dynamic library for threaded applications. |
mysqldemb.lib | Static library for not threaded applications. |
MySQL Server 4.0 laid the foundation for new features implemented in MySQL 4.1, such as subqueries and Unicode support, and for the work on stored procedures being done in version 5.0. These features come at the top of the wish list of many of our customers. Well-known for its stability, speed, and ease of use, MySQL Server is able to fulfill the requirement checklists of very demanding buyers.
MySQL Server 4.1 is currently in production status, and binaries are available for download at http://dev.mysql.com/downloads/mysql/4.1.html. All binary releases pass our extensive test suite without any errors on the platforms on which we test. See section D.2 Changes in release 4.1.x (Production).
For those wishing to use the most recent development source for MySQL 4.1, we also make our BitKeeper repositories publicly available. See section 2.8.3 Installing from the Development Source Tree.
This section lists features implemented in MySQL 4.1. New features that will be available in MySQL 5.0 are described in section C.1 New Features Planned for 5.0.
SELECT statement nested within another statement.
A ``derived table'' (an unnamed view) is a subquery in the FROM clause
of another statement.
See section 13.1.8 Subquery Syntax.
BTREE indexing is supported for HEAP tables,
significantly improving response time for non-exact searches.
CREATE TABLE tbl_name2 LIKE tbl_name1 allows you to create, with
a single statement, a new table with a structure exactly like that of an
existing table.
MyISAM storage engine supports
OpenGIS spatial types for storing geographical data.
See section 18 Spatial Extensions in MySQL.
SHOW WARNINGS shows warnings for the last command.
See section 13.5.4.20 SHOW WARNINGS Syntax.
utf8 and ucs2 character sets.
HELP command that can be used
to get help information for SQL statements.
The advantage of having this information on the server side is that the
information is always applicable to the particular server version that you
actually are using.
Because this information is available by issuing an SQL statement, any client
can be written to access it.
For example, the help command of the mysql command-line client
has been modified to have this capability.
INSERT ... ON DUPLICATE KEY UPDATE ... syntax has been
implemented. This allows you to UPDATE an existing row if the
INSERT would have caused a duplicate in a PRIMARY or
UNIQUE index.
See section 13.1.4 INSERT Syntax.
GROUP_CONCAT()
adds the extremely useful capability of concatenating column values from
grouped rows into a single result string.
See section 12.9 Functions and Modifiers for Use with GROUP BY Clauses.
The news section of this manual includes a more in-depth list of features. See section D.2 Changes in release 4.1.x (Production).
New development for MySQL is focused on the 5.0 release, featuring stored procedures, views (including updatable views), rudimentary triggers, and other new features. See section C.1 New Features Planned for 5.0.
For those wishing to take a look at the bleeding edge of MySQL development, we make our BitKeeper repository for MySQL version 5.0 publicly available. See section 2.8.3 Installing from the Development Source Tree. As of December 2003, binary builds of version 5.0 have also been available.
This section introduces the MySQL mailing lists and provides guidelines as to how the lists should be used. When you subscribe to a mailing list, you will receive all postings to the list as email messages. You can also send your own questions and answers to the list.
To subscribe to or unsubscribe from any of the mailing lists described in this section, visit http://lists.mysql.com/. For most of them, you can select the regular version of the list where you get individual messages, or a digest version where you get one large message per day.
Please do not send messages about subscribing or unsubscribing to any of the mailing lists, because such messages are distributed automatically to thousands of other users.
Your local site may have many subscribers to a MySQL mailing list.
If so, the site may have a local mailing list, so that messages sent from
lists.mysql.com to your site are propagated to the local list. In such
cases, please contact your system administrator to be added to or dropped
from the local MySQL list.
If you wish to have traffic for a mailing list go to a separate mailbox in
your mail program, set up a filter based on the message headers. You can
use either the List-ID: or Delivered-To: headers to identify
list messages.
The MySQL mailing lists are as follows:
announce
mysql
bugs
internals
mysqldoc
benchmarks
packagers
java
win32
myodbc
gui-tools
MySQL
Administrator and the MySQL Control Center graphical client.
cluster
dotnet
plusplus
perl
DBD::mysql.
If you're unable to get an answer to your questions from a MySQL mailing list, one option is to purchase support from MySQL AB. This will put you in direct contact with MySQL developers.
The following table shows some MySQL mailing lists in languages other than English. These lists are not operated by MySQL AB.
mysql-france-subscribe@yahoogroups.com
list@tinc.net
subscribe mysql your@email.address to this list.
mysql-de-request@lists.4t2.com
subscribe mysql-de your@email.address to this list.
You can find information about this mailing list at
http://www.4t2.com/mysql/.
mysql-br-request@listas.linkway.com.br
subscribe mysql-br your@email.address to this list.
mysql-alta@elistas.net
subscribe mysql your@email.address to this list.
Before posting a bug report or question, please do the following:
If you can't find an answer in the manual or the archives, check with your local MySQL expert. If you still can't find an answer to your question, please follow the guidelines on sending mail to a MySQL mailing list, outlined in the next section, before contacting us.
The normal place to report bugs is http://bugs.mysql.com/, which is the address for our bugs database. This database is public, and can be browsed and searched by anyone. If you log in to the system, you will also be able to enter new reports.
Writing a good bug report takes patience, but doing it right the first time saves time both for us and for yourself. A good bug report, containing a full test case for the bug, makes it very likely that we will fix the bug in the next release. This section will help you write your report correctly so that you don't waste your time doing things that may not help us much or at all.
We encourage everyone to use the mysqlbug script to generate a bug
report (or a report about any problem). mysqlbug can be
found in the `scripts' directory (source distribution) and in the
`bin' directory under your MySQL installation directory (binary distribution).
If you are unable to use mysqlbug (for example, if you are running
on Windows), it is still vital that you include all the necessary information
noted in this section (most importantly, a description of the operating system
and the MySQL version).
The mysqlbug script helps you generate a report by determining much
of the following information automatically, but if something important is
missing, please include it with your message. Please read this section
carefully and make sure that all the information described here is included
in your report.
Preferably, you should test the problem using the latest production or
development version of MySQL Server before posting. Anyone should be
able to repeat the bug by just using mysql test < script_file on the
included test case or by running the shell or Perl script that is included in the
bug report.
All bugs posted in the bugs database at http://bugs.mysql.com/ will be corrected or documented in the next MySQL release. If only minor code changes are needed to correct a problem, we may also post a patch that fixes the problem.
If you have found a sensitive security bug in MySQL, you can send email to security@mysql.com.
If you have a repeatable bug report, please report it to the bugs
database at http://bugs.mysql.com/. Note that even in this case
it's good to run the mysqlbug script first to find information
about your system. Any bug that we are able to repeat has a high chance
of being fixed in the next MySQL release.
To report other problems, you can use one of the MySQL mailing lists.
Remember that it is possible for us to respond to a message containing too much information, but not to one containing too little. People often omit facts because they think they know the cause of a problem and assume that some details don't matter. A good principle is this: If you are in doubt about stating something, state it. It is faster and less troublesome to write a couple more lines in your report than to wait longer for the answer if we must ask you to provide information that was missing from the initial report.
The most common errors made in bug reports are (a) not including the version number of the MySQL distribution used, and (b) not fully describing the platform on which the MySQL server is installed (including the platform type and version number). This is highly relevant information, and in 99 cases out of 100, the bug report is useless without it. Very often we get questions like, ``Why doesn't this work for me?'' Then we find that the feature requested wasn't implemented in that MySQL version, or that a bug described in a report has been fixed in newer MySQL versions. Sometimes the error is platform-dependent; in such cases, it is next to impossible for us to fix anything without knowing the operating system and the version number of the platform.
If you compiled MySQL from source, remember also to provide information about your compiler, if it is related to the problem. Often people find bugs in compilers and think the problem is MySQL-related. Most compilers are under development all the time and become better version by version. To determine whether your problem depends on your compiler, we need to know what compiler you use. Note that every compiling problem should be regarded as a bug and reported accordingly.
It is most helpful when a good description of the problem is included in the bug report. That is, give a good example of everything you did that led to the problem and describe, in exact detail, the problem itself. The best reports are those that include a full example showing how to reproduce the bug or problem. See section E.1.6 Making a Test Case If You Experience Table Corruption.
If a program produces an error message, it is very important to include the message in your report. If we try to search for something from the archives using programs, it is better that the error message reported exactly matches the one that the program produces. (Even the lettercase should be observed.) You should never try to reproduce from memory what the error message was; instead, copy and paste the entire message into your report.
If you have a problem with Connector/ODBC (MyODBC), please try to generate a trace file and send it with your report. See section 23.1.1.9 How to Report MyODBC Problems or Bugs.
Please remember that many of the people who will read your report will
do so using an 80-column display. When generating reports or examples
using the mysql command-line tool, you should therefore use
the --vertical option (or the \G statement terminator)
for output that would exceed the available width for such a display
(for example, with the EXPLAIN SELECT statement; see the
example later in this section).
Please include the following information in your report:
mysqladmin version. The mysqladmin
program can be found in the `bin' directory under your MySQL
installation directory.
uname -a.
mysqld died, you should also report the query that crashed
mysqld. You can usually find this out by running mysqld with
query logging enabled, and then looking in the log after mysqld crashes
See section E.1.5 Using Log Files to Find Cause of Errors in mysqld.
mysqldump --no-data db_name tbl_name. This is very easy
to do and is a powerful way to get information about any table in a database.
The information will help us create a situation matching the one you have.
SELECT statements, you
should always include the output of EXPLAIN SELECT ..., and at
least the number of rows that the SELECT statement produces. You
should also include the output from SHOW CREATE TABLE tbl_name
for each involved table. The more information you give about your
situation, the more likely it is that someone can help you.
The following is an example of a very good bug report. It should be posted
with the mysqlbug script. The example uses the mysql
command-line tool. Note the use of the \G statement terminator for
statements whose output width would otherwise exceed that of an 80-column
display device.
mysql> SHOW VARIABLES;
mysql> SHOW COLUMNS FROM ...\G
<output from SHOW COLUMNS>
mysql> EXPLAIN SELECT ...\G
<output from EXPLAIN>
mysql> FLUSH STATUS;
mysql> SELECT ...;
<A short version of the output from SELECT,
including the time taken to run the query>
mysql> SHOW STATUS;
<output from SHOW STATUS>
mysqld, try to provide an
input script that will reproduce the anomaly. This script should include any
necessary source files. The more closely the script can reproduce your
situation, the better. If you can make a reproducible test case, you should
post it on http://bugs.mysql.com/ for high-priority treatment.
If you can't provide a script, you should at least include the output
from mysqladmin variables extended-status processlist in your mail to
provide some information on how your system is performing.
mysqldump and create a `README' file
that describes your problem.
Create a compressed archive of your files using
tar and gzip or zip, and use FTP to transfer the
archive to ftp://ftp.mysql.com/pub/mysql/upload/. Then enter
the problem into our bugs database at http://bugs.mysql.com/.
mysqld
server as well as the options that you use to run any MySQL client programs.
The options to programs such as mysqld and mysql, and to the
configure script, are often keys to answers and are very relevant.
It is never a bad idea to include them. If you use any modules, such
as Perl or PHP, please include the version numbers of those as well.
mysqlaccess, the output of mysqladmin reload, and all
the error messages you get when trying to connect. When you test your
privileges, you should first run mysqlaccess. After this, execute
mysqladmin reload version and try to connect with the program that
gives you trouble. mysqlaccess can be found in the `bin'
directory under your MySQL installation directory.
parse error, please check your syntax closely. If
you can't find something wrong with it, it's extremely likely that your
current version of MySQL Server doesn't support the syntax you are
using. If you are using the current version and the manual at
http://dev.mysql.com/doc/ doesn't cover the
syntax you are using, MySQL Server doesn't support your query. In this
case, your only options are to implement the syntax yourself or email
licensing@mysql.com and ask for an offer to implement it.
If the manual covers the syntax you are using, but you have an older version
of MySQL Server, you should check the MySQL change history to see
when the syntax was implemented. In this case, you have the option of
upgrading to a newer version of MySQL Server. See section D MySQL Change History.
CHECK TABLE and REPAIR TABLE
or with myisamchk.
See section 5 Database Administration.
If you are running Windows, please verify that lower_case_table_names
is 1 or 2 with SHOW VARIABLES LIKE 'lower_case_table_names'.
mysqld should never crash a table if nothing killed it in the
middle of an update. If you can find the cause of mysqld dying,
it's much easier for us to provide you with a fix for the problem.
See section A.1 How to Determine What Is Causing a Problem.
If you are a support customer, please cross-post the bug report to mysql-support@mysql.com for higher-priority treatment, as well as to the appropriate mailing list to see whether someone else has experienced (and perhaps solved) the problem.
For information on reporting bugs in MyODBC, see section 23.1.1.9 How to Report MyODBC Problems or Bugs.
For solutions to some common problems, see section A Problems and Common Errors.
When answers are sent to you individually and not to the mailing list, it is considered good etiquette to summarize the answers and send the summary to the mailing list so that others may have the benefit of responses you received that helped you solve your problem.
If you consider your answer to have broad interest, you may want to post it to the mailing list instead of replying directly to the individual who asked. Try to make your answer general enough that people other than the original poster may benefit from it. When you post to the list, please make sure that your answer is not a duplication of a previous answer.
Try to summarize the essential part of the question in your reply; don't feel obliged to quote the entire original message.
Please don't post mail messages from your browser with HTML mode turned on. Many users don't read mail with a browser.
In addition to the various MySQL mailing lists, you can find experienced
community people on IRC (Internet Relay Chat).
These are the best networks/channels currently known to us:
#mysql
Primarily MySQL questions, but other database and general SQL questions are welcome.
Questions about PHP, Perl or C in combination with MySQL are also common.
#mysql
MySQL questions.
If you are looking for IRC client software to connect to an IRC network,
take a look at X-Chat (http://www.xchat.org/).
X-Chat (GPL licensed) is available for Unix as well as for Windows platforms.
The latest community support resource are the forums at http://forums.mysql.com.
There are a variety of forums available, grouped in the following general categories:
This section describes how MySQL relates to the ANSI/ISO SQL standards. MySQL Server has many extensions to the SQL standard, and here you will find out what they are and how to use them. You will also find information about functionality missing from MySQL Server, and how to work around some differences.
The SQL standard has been evolving since 1986 and several versions exist. In this manual, ``SQL-92'' refers to the standard released in 1992, ``SQL:1999'' refers to the standard released in 1999, and ``SQL:2003'' refers to the current version of the standard. We use the phrase ``the SQL standard'' to mean the current version of the SQL Standard at any time.
Our goal is to not restrict MySQL Server usability for any usage without a very good reason for doing so. Even if we don't have the resources to perform development for every possible use, we are always willing to help and offer suggestions to people who are trying to use MySQL Server in new territories.
One of our main goals with the product is to continue to work toward
compliance with the SQL standard, but without sacrificing speed or reliability.
We are not afraid to add extensions to SQL or support for non-SQL
features if this greatly increases the usability of MySQL Server for a large
segment of our user base.
The HANDLER interface in MySQL Server 4.0 is an example of this
strategy. See section 13.1.3 HANDLER Syntax.
We will continue to support transactional and non-transactional databases to satisfy both mission-critical 24/7 usage and heavy Web or logging usage.
MySQL Server was originally designed to work with medium size databases (10-100 million rows, or about 100MB per table) on small computer systems. Today MySQL Server handles terabyte-size databases, but the code can also be compiled in a reduced version suitable for hand-held and embedded devices. The compact design of the MySQL server makes development in both directions possible without any conflicts in the source tree.
Currently, we are not targeting realtime support, although MySQL replication capabilities offer significant functionality.
Database cluster support exists through third-party clustering solutions as well as the integration of our acquired NDB Cluster technology, available from version 4.1.2. See section 16 MySQL Cluster.
We are also looking at providing XML support in the database server.
We are aiming toward supporting the full ANSI/ISO SQL standard, but without making concessions to speed and quality of the code.
ODBC levels 0-3.51.
The MySQL server can operate in different SQL modes, and can apply these modes differentially for different clients. This allows an application to tailor server operation to its own requirements.
Modes define what SQL syntax MySQL should support and what kind of validation checks it should perform on the data. This makes it easier to use MySQL in a lot of different environments and to use MySQL together with other database servers.
You can set the default SQL mode by starting mysqld with the
--sql-mode="modes" option. Beginning with MySQL 4.1, you can also
change the mode after startup time by setting the sql_mode variable
with a SET [SESSION|GLOBAL] sql_mode='modes' statement.
For more information on setting the server mode, see section 5.2.2 The Server SQL Mode.
You can tell mysqld to use the ANSI mode with the --ansi
startup option. See section 5.2.1 mysqld Command-Line Options.
Running the server in ANSI mode is the same as starting it with these options
(specify the --sql_mode value on a single line):
--transaction-isolation=SERIALIZABLE --sql-mode=REAL_AS_FLOAT,PIPES_AS_CONCAT,ANSI_QUOTES, IGNORE_SPACE,ONLY_FULL_GROUP_BY
In MySQL 4.1, you can achieve the same effect with these two statements
(specify the sql_mode value on a single line):
SET GLOBAL TRANSACTION ISOLATION LEVEL SERIALIZABLE; SET GLOBAL sql_mode = 'REAL_AS_FLOAT,PIPES_AS_CONCAT,ANSI_QUOTES, IGNORE_SPACE,ONLY_FULL_GROUP_BY';
See section 1.5.2 Selecting SQL Modes.
In MySQL 4.1.1, the sql_mode options shown can be also be set with
this statement:
SET GLOBAL sql_mode='ansi';
In this case, the value of the sql_mode variable will be set to all
options that are relevant for ANSI mode. You can check the result like this:
mysql> SET GLOBAL sql_mode='ansi';
mysql> SELECT @@global.sql_mode;
-> 'REAL_AS_FLOAT,PIPES_AS_CONCAT,ANSI_QUOTES,
IGNORE_SPACE,ONLY_FULL_GROUP_BY,ANSI';
MySQL Server includes some extensions that you probably will not find in
other SQL databases. Be warned that if you use them, your code will not be
portable to other SQL servers. In some cases, you can write code that
includes MySQL extensions, but is still portable, by using comments
of the form /*! ... */. In this case, MySQL Server will parse and
execute the code within the comment as it would any other MySQL
statement, but other SQL servers will ignore the extensions. For example:
SELECT /*! STRAIGHT_JOIN */ col_name FROM table1,table2 WHERE ...
If you add a version number after the `!' character, the syntax within the comment will be executed only if the MySQL version is equal to or newer than the specified version number:
CREATE /*!32302 TEMPORARY */ TABLE t (a INT);
This means that if you have Version 3.23.02 or newer, MySQL
Server will use the TEMPORARY keyword.
The following descriptions list MySQL extensions, organized by category.
MyISAM or ISAM storage engines.
For example, to rename a MyISAM table, rename the `.MYD',
`.MYI', and `.frm' files to which the table corresponds.
User space.
MySQL Server doesn't support tablespaces such as used in statements like this:
CREATE TABLE ralph.my_table...IN my_tablespace.
ANALYZE TABLE, CHECK TABLE, OPTIMIZE TABLE, and
REPAIR TABLE statements.
CREATE DATABASE and DROP DATABASE statements.
See section 13.2.4 CREATE DATABASE Syntax.
DO statement.
EXPLAIN SELECT to get a description of how tables are joined.
FLUSH and RESET statements.
SET statement. See section 13.5.3 SET Syntax.
SHOW statement.
See section 13.5.4 SHOW Syntax.
LOAD DATA INFILE. In many cases, this syntax is compatible with
Oracle's LOAD DATA INFILE. See section 13.1.5 LOAD DATA INFILE Syntax.
RENAME TABLE. See section 13.2.12 RENAME TABLE Syntax.
REPLACE instead of DELETE + INSERT.
See section 13.1.6 REPLACE Syntax.
CHANGE col_name, DROP col_name, or DROP
INDEX, IGNORE or RENAME in an ALTER TABLE
statement.
Use of multiple ADD, ALTER, DROP, or CHANGE
clauses in an ALTER TABLE statement.
See section 13.2.2 ALTER TABLE Syntax.
INDEX or KEY in a CREATE TABLE
statement. See section 13.2.6 CREATE TABLE Syntax.
TEMPORARY or IF NOT EXISTS with CREATE TABLE.
IF EXISTS with DROP TABLE.
DROP TABLE statement.
ORDER BY and LIMIT clauses of the UPDATE and
DELETE statements.
INSERT INTO ... SET col_name = ... syntax.
DELAYED clause of the INSERT and REPLACE
statements.
LOW_PRIORITY clause of the INSERT, REPLACE,
DELETE, and UPDATE statements.
INTO OUTFILE and STRAIGHT_JOIN in a SELECT
statement. See section 13.1.7 SELECT Syntax.
SQL_SMALL_RESULT option in a SELECT statement.
GROUP BY part.
This gives better performance for some very specific, but quite normal
queries.
See section 12.9 Functions and Modifiers for Use with GROUP BY Clauses.
ASC and DESC with GROUP BY.
:= assignment
operator:
mysql> SELECT @a:=SUM(total),@b=COUNT(*),@a/@b AS avg
-> FROM test_table;
mysql> SELECT @t1:=(@t2:=1)+@t3:=4,@t1,@t2,@t3;
MEDIUMINT, SET, ENUM, and the
different BLOB and TEXT types.
AUTO_INCREMENT, BINARY, NULL,
UNSIGNED, and ZEROFILL.
|| and && operators to mean
logical OR and AND, as in the C programming language. In MySQL Server,
|| and OR are synonyms, as are && and AND.
Because of this nice syntax, MySQL Server doesn't support
the standard SQL || operator for string concatenation; use
CONCAT() instead. Because CONCAT() takes any number
of arguments, it's easy to convert use of the || operator to
MySQL Server.
COUNT(DISTINCT list) where list has more than one element.
BINARY attribute or use the BINARY cast, which causes
comparisons to be done using the underlying character code values rather
then a lexical ordering.
% operator is a synonym for MOD(). That is,
N % M is equivalent to MOD(N,M). % is supported
for C programmers and for compatibility with PostgreSQL.
=, <>, <= ,<, >=,>,
<<, >>, <=>, AND, OR, or LIKE
operators may be used in column comparisons to the left of the
FROM in SELECT statements. For example:
mysql> SELECT col1=1 AND col2=2 FROM tbl_name;
LAST_INSERT_ID() function that returns the most recent
AUTO_INCREMENT value.
See section 12.8.3 Information Functions.
LIKE is allowed on numeric columns.
REGEXP and NOT REGEXP extended regular expression
operators.
CONCAT() or CHAR() with one argument or more than two
arguments. (In MySQL Server, these functions can take any number of
arguments.)
BIT_COUNT(), CASE, ELT(),
FROM_DAYS(), FORMAT(), IF(), PASSWORD(),
ENCRYPT(), MD5(), ENCODE(), DECODE(),
PERIOD_ADD(), PERIOD_DIFF(), TO_DAYS(), and
WEEKDAY() functions.
TRIM() to trim substrings. Standard SQL supports removal
of single characters only.
GROUP BY functions STD(), BIT_OR(),
BIT_AND(), BIT_XOR(), and GROUP_CONCAT().
See section 12.9 Functions and Modifiers for Use with GROUP BY Clauses.
For a prioritized list indicating when new extensions will be added to MySQL Server, you should consult the online MySQL TODO list at http://dev.mysql.com/doc/mysql/en/TODO.html. That is the latest version of the TODO list in this manual. See section C MySQL and the Future (the TODO).
We try to make MySQL Server follow the ANSI SQL standard and the ODBC SQL standard, but MySQL Server performs operations differently in some cases:
VARCHAR columns, trailing spaces are removed when the value is
stored. (Fixed in MySQL 5.0.3). See section 1.5.7 Known Errors and Design Deficiencies in MySQL.
CHAR columns are silently converted to VARCHAR
columns when you define a table or alter its structure. (Fixed in MySQL 5.0.3).
See section 13.2.6.1 Silent Column Specification Changes.
REVOKE statement to revoke
privileges for a table. See section 13.5.1.3 GRANT and REVOKE Syntax.
CAST() function does not support cast to REAL or
BIGINT. See section 12.7 Cast Functions and Operators.
HAVING clause in a SELECT
statement be able to refer to columns in the GROUP BY clause. This
cannot be done before MySQL 5.0.2.
MySQL 4.1 supports subqueries and derived tables.
A ``subquery'' is a SELECT statement nested within another statement.
A ``derived table'' (an unnamed view) is a subquery in the FROM clause
of another statement.
See section 13.1.8 Subquery Syntax.
For MySQL versions older than 4.1, most subqueries can be rewritten using joins or other methods. See section 13.1.8.11 Rewriting Subqueries as Joins for Earlier MySQL Versions for examples that show how to do this.
SELECT INTO TABLE
MySQL Server doesn't support the Sybase SQL extension:
SELECT ... INTO TABLE .... Instead, MySQL Server supports the
standard SQL syntax INSERT INTO ... SELECT ..., which is basically
the same thing. See section 13.1.4.1 INSERT ... SELECT Syntax.
INSERT INTO tbl_temp2 (fld_id)
SELECT tbl_temp1.fld_order_id
FROM tbl_temp1 WHERE tbl_temp1.fld_order_id > 100;
Alternatively, you can use SELECT INTO OUTFILE ... or
CREATE TABLE ... SELECT.
From version 5.0, MySQL supports SELECT ... INTO with user
variables. The same syntax may also be used inside stored procedures using
cursors and local variables.
See section 19.1.6.3 SELECT ... INTO Statement.
MySQL Server (version 3.23-max and all versions 4.0 and above) supports
transactions with the InnoDB and BDB
transactional storage engines.
InnoDB provides full ACID compliance.
See section 14 MySQL Storage Engines and Table Types.
The other non-transactional storage engines in MySQL Server (such as
MyISAM) follow a different paradigm for data integrity called
``atomic operations.'' In transactional terms, MyISAM
tables effectively always operate in AUTOCOMMIT=1 mode.
Atomic operations often offer comparable integrity with higher performance.
With MySQL Server supporting both paradigms, you can decide whether your applications are best served by the speed of atomic operations or the use of transactional features. This choice can be made on a per-table basis.
As noted, the trade-off for transactional versus non-transactional table
types lies mostly in performance. Transactional tables have significantly
higher memory and diskspace requirements, and more CPU overhead.
On the other hand, transactional table types such as InnoDB also
offer many significant features. MySQL Server's modular design allows the
concurrent use of different storage engines to suit different
requirements and deliver optimum performance in all situations.
But how do you use the features of MySQL Server to maintain rigorous
integrity even with the non-transactional MyISAM tables, and how
do these features compare with the transactional table types?
ROLLBACK rather than
COMMIT in critical situations, transactions are more
convenient. Transactions also ensure that unfinished updates or
corrupting activities are not committed to the database; the server is
given the opportunity to do an automatic rollback and your database is
saved.
If you use non-transactional tables,
MySQL Server in almost all cases allows you to resolve potential problems
by including simple checks before updates and by running simple scripts
that check the databases for inconsistencies and automatically repair
or warn if such an inconsistency occurs. Note that just by using the
MySQL log or even adding one extra log, you can normally fix tables
perfectly with no data integrity loss.
LOCK TABLES or atomic updates, ensuring
that you never will get an automatic abort from the server, which is
a common problem with transactional database systems.
The transactional paradigm has its benefits and its drawbacks. Many users and application developers depend on the ease with which they can code around problems where an abort appears to be, or is necessary. However, even if you are new to the atomic operations paradigm, or more familiar with transactions, do consider the speed benefit that non-transactional tables can offer on the order of three to five times the speed of the fastest and most optimally tuned transactional tables.
In situations where integrity is of highest importance, MySQL Server offers
transaction-level reliability and integrity even for non-transactional tables.
If you lock tables with LOCK TABLES, all updates will stall
until any integrity checks are made. If you obtain a READ LOCAL lock
(as opposed to a write lock) for a table that allows concurrent inserts at the
end of the table, reads are allowed, as are inserts by other clients.
The new inserted records will not be seen by the
client that has the read lock until it releases the lock.
With INSERT DELAYED, you can queue inserts into a local
queue, until the locks are released, without having the client wait
for the insert to complete. See section 13.1.4.2 INSERT DELAYED Syntax.
``Atomic,'' in the sense that we mean it, is nothing magical. It only means that you can be sure that while each specific update is running, no other user can interfere with it, and there will never be an automatic rollback (which can happen with transactional tables if you are not very careful). MySQL Server also guarantees that there will not be any dirty reads.
Following are some techniques for working with non-transactional tables:
LOCK TABLES, and you don't need cursors to update
records on the fly.
ROLLBACK, you can use the following strategy:
LOCK TABLES to lock all the tables you want to access.
UNLOCK TABLES to release your locks.
WHERE clause in the UPDATE statement. If the record wasn't
updated, we give the client a message: ``Some of the data you have changed
has been changed by another user.'' Then we show the old row versus the new
row in a window so that the user can decide which version of the customer
record to use.
This gives us something that is similar to column locking but is actually
even better because we only update some of the columns, using values that
are relative to their current values. This means that typical UPDATE
statements look something like these:
UPDATE tablename SET pay_back=pay_back+125;
UPDATE customer
SET
customer_date='current_date',
address='new address',
phone='new phone',
money_owed_to_us=money_owed_to_us-125
WHERE
customer_id=id AND address='old address' AND phone='old phone';
This is very efficient and works even if another client
has changed the values in the pay_back or money_owed_to_us
columns.
LOCK TABLES and/or ROLLBACK
for the purpose of managing unique identifiers. This can be handled much
more efficiently without locking or rolling back by using an
AUTO_INCREMENT column and either the
LAST_INSERT_ID() SQL function or the mysql_insert_id() C API function.
See section 12.8.3 Information Functions.
See section 22.2.3.33 mysql_insert_id().
You can generally code around the need for row-level locking. Some situations
really do need it, and InnoDB tables support row-level locking. With
MyISAM tables, you can use a flag column in the table and do something
like the following:
UPDATE tbl_name SET row_flag=1 WHERE id=ID;MySQL returns
1 for the number of affected rows if the row was
found and row_flag wasn't 1 in the original row.
You can think of it as though MySQL Server changed the preceding query to:
UPDATE tbl_name SET row_flag=1 WHERE id=ID AND row_flag <> 1;
Stored procedures are implemented in MySQL version 5.0. See section 19 Stored Procedures and Functions.
Triggers are currently being implemented, with basic functionality in MySQL 5.0, with further development planned for MySQL 5.1.
In MySQL Server 3.23.44 and up, the InnoDB storage engine supports
checking of foreign key constraints, including CASCADE, ON
DELETE, and ON UPDATE. See section 15.7.4 FOREIGN KEY Constraints.
For storage engines other than InnoDB, MySQL Server parses the
FOREIGN KEY syntax in CREATE TABLE statements, but does not
use or store it. In the future, the implementation will be
extended to store this information in the table specification file so that it
may be retrieved by mysqldump and ODBC. At a later stage,
foreign key constraints will be implemented for MyISAM tables as well.
Foreign key enforcement offers several benefits to database developers:
Do keep in mind that these benefits come at the cost of additional overhead for the database server to perform the necessary checks. Additional checking by the server affects performance, which for some applications may be sufficiently undesirable as to be avoided if possible. (Some major commercial applications have coded the foreign-key logic at the application level for this reason.)
MySQL gives database developers the choice of which approach to use. If you
don't need foreign keys and want to avoid the overhead associated with
enforcing referential integrity, you can choose another table type instead,
such as MyISAM. (For example, the MyISAM storage engine offers
very fast performance for applications that perform only INSERT and
SELECT operations, because the inserts can be performed concurrently
with retrievals. See section 7.3.2 Table Locking Issues.)
If you choose not to take advantage of referential integrity checks, keep the following considerations in mind:
ON DELETE is the only referential integrity capability an
application needs, note that as of MySQL Server 4.0, you can use
multiple-table DELETE statements to delete rows from many
tables with a single statement. See section 13.1.1 DELETE Syntax.
ON DELETE is to add
the appropriate DELETE statement to your application when you
delete records from a table that has a foreign key. In practice, this is often
as quick as using foreign keys, and is more portable.
Be aware that the use of foreign keys can in some instances lead to problems:
FOREIGN KEY Constraints.
As of MySQL 4.1.1,
mysqldump generates dump files that take advantage of this
capability automatically when reloaded.)
Note that foreign keys in SQL are used to check and enforce referential
integrity, not to join tables. If you want to get results from multiple
tables from a SELECT statement, you do this by performing a join
between them:
SELECT * FROM t1, t2 WHERE t1.id = t2.id;
See section 13.1.7.1 JOIN Syntax. See section 3.6.6 Using Foreign Keys.
The FOREIGN KEY syntax without ON DELETE ... is often used
by ODBC applications to produce automatic WHERE clauses.
Views (including updatable views) are implemented in the 5.0 version
of MySQL Server. Views are available in binary releases from 5.0.1
and up.
See section 13.2.7 CREATE VIEW Syntax.
Views are useful for allowing users to access a set of relations (tables) as if it were a single table, and limiting their access to just that. Views can also be used to restrict access to rows (a subset of a particular table). For access control to columns, you can also use the sophisticated privilege system in MySQL Server. See section 5.5 The MySQL Access Privilege System.
In designing an implementation of views, our ambitious goal, as much as is possible within the confines of SQL, has been full compliance with ``Codd's Rule #6'' for relational database systems: ``All views that are theoretically updatable, should in practice also be updatable.''
Some other SQL databases use `--' to start comments.
MySQL Server uses `#' as the start comment character. You can also use
the C comment style /* this is a comment */ with MySQL Server.
See section 9.5 Comment Syntax.
MySQL Server 3.23.3 and above support the `--' comment style,
provided the comment is followed by a space (or by a control character such
as a newline). The requirement for a space is to prevent problems with
automatically generated SQL queries that have used something like the following code, where we automatically insert the value of the payment for
!payment!:
UPDATE account SET credit=credit-!payment!
Think about what happens if the value of payment is a negative value
such as -1:
UPDATE account SET credit=credit--1
credit--1 is a legal expression in SQL, but if -- is interpreted
as the start of a comment, part of the expression is discarded. The result is a
statement that has a completely different meaning than intended:
UPDATE account SET credit=credit
The statement produces no change in value at all! This illustrates that allowing comments to start with `--' can have serious consequences.
Using our implementation of this method of commenting in MySQL Server
3.23.3 and up, credit--1 is actually safe.
Another safe feature is that the mysql command-line client
removes all lines that start with `--'.
The following information is relevant only if you are running a MySQL version earlier than 3.23.3:
If you have an SQL program in a text file that contains `--'
comments, you should use the replace utility as follows to convert the
comments to use `#' characters:
shell> replace " --" " #" < text-file-with-funny-comments.sql \
| mysql db_name
instead of the usual:
shell> mysql db_name < text-file-with-funny-comments.sql
You can also edit the command file ``in place'' to change the `--' comments to `#' comments:
shell> replace " --" " #" -- text-file-with-funny-comments.sql
Change them back with this command:
shell> replace " #" " --" -- text-file-with-funny-comments.sql
MySQL allows you to work both with transactional tables that allow rollback and with non-transactional tables that do not. Because of this, constraint handling is a bit different in MySQL than in other databases. We must handle the case when you have inserted or updated a lot of rows in a non-transactional table for which changes cannot be rolled back when an error occurs.
The basic philosophy is that MySQL Server tries to produce an error for anything that it can detect while parsing a statement to be executed, and tries to recover from any errors that occur while executing the statement. We do this in most cases, but not yet for all. See section C.3 New Features Planned for the Near Future.
The options MySQL has when an error occurs are to stop the statement in the middle or to recover as well as possible from the problem and continue. By default, the server follows the latter course. This means, for example, that the server may coerce illegal values to the closest legal values.
Beginning with MySQL 5.0.2, several SQL mode options are available to provide greater control over how accepting to be of bad data values and whether to continue executing a statement or abort it when errors occur. Using these options, you can configure MySQL Server to act in a more traditional fashion that is like other DBMSs that reject improper input. The SQL mode can be set at runtime, which enables individual clients to select the behavior most appropriate for their requirements. See section 5.2.2 The Server SQL Mode.
The following sections describe what happens for the different types of constraints.
PRIMARY KEY and UNIQUE Index Constraints
Normally, an error occurs when you try to INSERT or UPDATE
a row that causes a primary key, unique key, or foreign key violation.
If you are using a transactional storage engine such as InnoDB, MySQL
automatically rolls back the statement. If you are using a non-transactional
storage engine, MySQL stops processing the statement at the row for which
the error occurred and leaves any remaining rows unprocessed.
If you wish to ignore such key violations, MySQL supports an IGNORE
keyword for INSERT and UPDATE. In this case, MySQL ignores
any key violations and continues processing with the next row.
See section 13.1.4 INSERT Syntax.
See section 13.1.10 UPDATE Syntax.
You can get information about the number of rows actually inserted or
updated with the mysql_info() C API function.
See section 22.2.3.31 mysql_info().
In MySQL 4.1 and up, you also can use the SHOW WARNINGS statement.
See section 13.5.4.20 SHOW WARNINGS Syntax.
For the moment, only InnoDB tables support foreign keys.
See section 15.7.4 FOREIGN KEY Constraints.
Foreign key support in MyISAM tables is scheduled for implementation
in MySQL 5.1.
Before MySQL 5.0.2, MySQL is forgiving of illegal or improper data values and coerces them to legal values for data entry. In MySQL 5.0.2 and up, that remains the default behavior, but you can select more traditional treatment of bad values such that the server rejects them and aborts the statement in which they occur. This section describes the default (forgiving) behavior of MySQL, as well as the newer strict SQL mode and how it differs.
The following holds true when you are not using strict mode.
If you insert an ``incorrect'' value into a column, such as a NULL
into a NOT NULL column or a too-large numeric value into a
numeric column, MySQL sets the column to the ``best possible value''
instead of producing an error:
NULL into a column that doesn't take NULL
values, MySQL Server stores 0 or '' (the empty string) instead.
DATE and
DATETIME columns (such as '2000-02-31' or '2000-02-00').
The idea is that it's not the job of the SQL server to validate dates. If
MySQL can store a date value and retrieve exactly the same value, MySQL
stores it as given. If the date is totally wrong (outside the server's
ability to store it), the special date value '0000-00-00' is stored
in the column instead.
INSERT statement specifies no value for a column, MySQL inserts
its default value if the column definition includes an explicit DEFAULT
clause. If the definition has no such DEFAULT clause, MySQL inserts
the implicit default value for the column data type. In general,
this is the empty string for string columns, 0 for numeric columns,
and '0000-00-00' for date columns. Implicit default values are
discussed in section 13.2.6 CREATE TABLE Syntax.
The reason for the preceding rules is that we can't check these conditions until the statement has begun executing. We can't just roll back if we encounter a problem after updating a few rows, because the storage engine may not support rollback. The option of terminating the statement is not that good; in this case, the update would be ``half done,'' which is probably the worst possible scenario. In this case, it's better to ``do the best you can'' and then continue as if nothing happened.
In MySQL 5.0.2 and up, you can select stricter treatment of input values by
using the STRICT_TRANS_TABLES or STRICT_ALL_TABLES SQL modes.
See section 5.2.2 The Server SQL Mode.
STRICT_TRANS_TABLES works like this: For transactional storage
engines, bad data values occurring anywhere in the statement causes
the to abort and roll back. For non-transactional storage engines,
the statement aborts if the error occurs in the first row to be inserted
or updated. (In this case, the statement can be regarded to leave the
table unchanged, just as for a transactional table.) Errors in rows
after the first do not abort the statement. Instead, bad data values
are adjusted and result in warnings rather than errors. In other words,
with STRICT_TRANS_TABLES, a wrong value causes MySQL to roll back,
if it can, all updates done so far.
For stricter checking, enable STRICT_ALL_TABLES. This is the same as
STRICT_TRANS_TABLES except that for non-transactional storage engines,
errors abort the statement even for bad data in rows following the first row.
This means that if an error occurs partway through a multiple-row insert or
update for a non-transactional table, a partial update results. Earlier rows
are inserted or updated, but those from the point of the error on are not.
To avoid this for non-transactional tables, either use single-row statements
or else use STRICT_TRANS_TABLES if conversion warnings rather than
errors are acceptable. To avoid problems in the first place, do not use
MySQL to check column content. It is safest (and often faster) to let the
application ensure that it passes only legal values to the database.
With either of the strict mode options, you can cause errors to be treated
as warnings by using INSERT IGNORE or UPDATE IGNORE.
ENUM and SET Constraints
ENUM and SET columns provide an efficient way to define columns
that can contain only a given set of values. However, before MySQL 5.0.2,
ENUM and SET are not real constraints. This is for the same
reasons that NOT NULL is not honored.
See section 1.5.6.2 Constraints on Invalid Data.
ENUM columns always have a default value. If you don't specify
a default value, then it will be NULL for columns that can have
NULL, otherwise the first enumeration value is used as the default
value.
If you insert an incorrect value into an ENUM column or if you
force a value into an ENUM column with IGNORE, it is set
to the reserved enumeration value of 0, which is displayed as an
empty string in string context. See section 11.4.4 The ENUM Type.
If you insert an incorrect value into a SET column, the incorrect value
is ignored. For example, if the column can contain the values
'a', 'b', and 'c', an attempt to assign 'a,x,b,y'
results in a value of 'a,b'.
See section 11.4.5 The SET Type.
As of MySQL 5.0.2, you can configure the server to use strict SQL mode.
See section 5.2.2 The Server SQL Mode.
When strict mode is not enabled, values entered into ENUM and SET
columns are handled as just described for MySQL 4.x. However, if strict
mode is enabled, the definition of a ENUM or SET column does
act as a constraint on values entered into the column. An error occurs
for values that do not satisfy these conditions:
ENUM value must be one of those listed in the column definition, or
the internal numeric equivalent thereof. The value cannot be the error value
(that is, 0 or the empty string).
For a column defined as ENUM('a','b','c'), values such as '',
'd', and 'ax' are illegal and are rejected.
SET value must be the empty string or a value consisting of one or
more of the values listed in the column definition separated by commas.
For a column defined as SET('a','b','c'), values such as
'd', and 'a,b,c,d' are illegal and are rejected.
Errors for invalid values can be suppressed in strict mode if you use
INSERT IGNORE or UPDATE IGNORE. In this case, a warning is
generated rather than an error. For ENUM, the value is inserted as the
error member (0). For SET, the value is inserted as given except
that any invalid substrings are deleted. For example, 'a,x,b,y'
results in a value of 'a,b', as described earlier.
The following known errors or bugs are not fixed in MySQL 3.23 because fixing them would involve changing a lot of code that could introduce other even worse bugs. The bugs are also classified as ``not fatal'' or ``bearable.''
LOCK TABLE to lock
multiple tables and then in the same connection use DROP TABLE to
drop one of them while another thread is trying to lock it. (To break the
deadlock, you can use KILL to terminate any of the threads involved.)
This issue is resolved as of MySQL 4.0.12.
SELECT MAX(key_column) FROM t1,t2,t3... where one of the tables are
empty doesn't return NULL but instead returns the maximum value for the
column. This issue is resolved as of MySQL 4.0.11.
DELETE FROM heap_table without a WHERE clause doesn't work on
a locked HEAP table.
The following known errors or bugs are not fixed in MySQL 4.0 because fixing them would involve changing a lot of code that could introduce other even worse bugs. The bugs are also classified as ``not fatal'' or ``bearable.''
HAVING you can get a crash or wrong result if you use an alias to
a RAND() function. This is fixed in 4.1.10 but will not be fixed
in 4.0 because the fix 'may' cause side effects for some applications.
UNION, the first SELECT determines the type,
max_length, and NULL properties for the resulting
columns. This issue is resolved as of MySQL 4.1.1; the property values are
based on the rows from all UNION parts.
DELETE with many tables, you can't refer to tables to be
deleted through an alias. This is fixed as of MySQL 4.1.
UNION ALL and UNION DISTINCT in the same query.
If you use ALL for one UNION, it is used for all
of them. This is fixed as of MySQL 4.1.2. The rules for mixed UNION
types are given in section 13.1.7.2 UNION Syntax.
FLUSH TABLES WITH READ LOCK does not block CREATE TABLE, which
may cause a problem with the binary log position when
doing a full backup of tables and the binary log.
mysqldump --single-transaction --master-data behaved like
mysqldump --master-data, so the dump was a blocking one. This is fixed
starting from MySQL 4.1.8.
RPAD() function (or any function adding spaces to the
right) in a query that had to be resolved by using a temporary table, all
resulting strings had rightmost spaces removed (i.e. RPAD() did not
work).
The following problems are known and fixing them is a high priority:
NULL value to a subquery using ALL/ANY/SOME
and the subquery returns an empty result, the comparison might evaluate
to the non-standard result of NULL rather than to TRUE or
FALSE. This will be fixed in MySQL 5.0.
lower_case_table_names=2 (which enables
MySQL to remember the used case for databases and table names) MySQL
will not on case insensitive systems remember the used case for database
names for the function DATABASE() or in various logs.
FOREIGN KEY constraint doesn't work in replication because
the constraint may have another name on the slave.
REPLACE (and LOAD DATA with the REPLACE option) does not
trigger ON DELETE CASCADE.
DISTINCT with ORDER BY doesn't work inside GROUP_CONCAT()
if you don't use all and only those columns that are in the
DISTINCT list.
DROP TABLE command before the table is
used in the transaction itself. We plan to fix this in 5.0 by
having the DROP TABLE wait until the table is not used in any
transaction.
FLUSH TABLES WITH READ LOCK does not block COMMIT if the server
is running without binary logging, which may cause a problem (of consistency
between tables) when doing a full backup.
ANALYZE TABLE on a BDB table may in some cases make the table
unusable until you restart mysqld. If this happens, you will
see errors of the following form in the MySQL error file:
001207 22:07:56 bdb: log_flush: LSN past current end-of-log
FROM clause of a SELECT
statement, but silently
ignores them. The reason for not giving an error is that many clients
that automatically generate queries add parentheses in the FROM
clause even where they are not needed.
RIGHT JOINS or combining LEFT and
RIGHT join in the same query may not give a correct answer because
MySQL only generates NULL rows for the table preceding a LEFT or
before a RIGHT join. This will be fixed in 5.0 at the same time
we add support for parentheses in the FROM clause.
ALTER TABLE on a BDB table on which you are
running multiple-statement transactions until all those transactions complete.
(The transaction will probably be ignored.)
ANALYZE TABLE, OPTIMIZE TABLE, and REPAIR TABLE may
cause problems on tables for which you are using INSERT DELAYED.
LOCK TABLE ... and FLUSH TABLES ... doesn't
guarantee that there isn't a half-finished transaction in progress on the
table.
BDB tables are a bit slow to open. If you have many BDB tables
in a database, it will take a long time to use the mysql client on
the database if you are not using the -A option or if you are using
rehash. This is especially notable when you have a large table cache.
CREATE ... SELECT or
INSERT ... SELECT statements that
insert zero or NULL values into an AUTO_INCREMENT column.
DELETE if you are
deleting rows from a table that has foreign keys with ON DELETE
CASCADE properties.
REPLACE ... SELECT,
INSERT IGNORE ... SELECT if you have
duplicate key values in the inserted data.
ORDER BY
clause guaranteeing a deterministic order.
For example, for INSERT ... SELECT with no ORDER
BY, the SELECT may return rows in a different order
(which will result in a row having different ranks, hence getting a
different number in the AUTO_INCREMENT column),
depending on the choices made by the optimizers on the master and
slave. A query will be optimized differently on the master and slave only if:
OPTIMIZE TABLE was run on the master tables and not on
the slave tables. (To fix this, OPTIMIZE TABLE, ANALYZE TABLE,
and REPAIR TABLE are written to the binary log as of MySQL 4.1.1).
InnoDB on the master,
but MyISAM on the slave if the slave has less available disk
space.)
key_buffer_size, and so on) are different on
the master and slave.
mysqlbinlog|mysql.
The easiest way to avoid this problem in all cases is to add an
ORDER BY clause to
such non-deterministic queries to ensure that the rows are always
stored or modified in the same order.
In future MySQL versions, we will automatically add an ORDER BY
clause when needed.
The following problems are known and will be fixed in due time:
--log-bin=old_host_name-bin if you change your hostname to something
else. Another option is to just rename the old files to reflect your
hostname change (and if these are binary logs, you will also need to edit the
binary log index file and fix the binlog names there). See section 5.2.1 mysqld Command-Line Options.
mysqlbinlog will not delete temporary files left after a
LOAD DATA INFILE command. See section 8.5 The mysqlbinlog Binary Log Utility.
RENAME doesn't work with TEMPORARY tables or tables used in a
MERGE table.
CHAR(255)) in table names, column names, or enumerations.
This is scheduled to be fixed in version 5.1 when we have new table
definition format files.
SET CHARACTER SET, you can't use translated
characters in database, table, and column names.
ESCAPE in LIKE
... ESCAPE.
DECIMAL column in which the same number is stored in
different formats (for example, +01.00, 1.00, 01.00),
GROUP BY may regard each value as a different value.
BLOB and TEXTvalues can't ``reliably'' be used in GROUP
BY or ORDER BY or DISTINCT. Only the first
max_sort_length bytes are used when comparing BLOB values in
these cases. The default value of max_sort_length value is 1024. It
can be changed at server startup time. As of MySQL 4.0.3, it can also be
changed at runtime. For older versions, a workaround for most cases is to
use a substring. For example:
SELECT DISTINCT LEFT(blob_col,2048) FROM tbl_name;
BIGINT or DOUBLE (both are
normally 64 bits long). Which precision you get depends on the function.
The general rule is that bit functions are done with BIGINT
precision, IF and ELT() with BIGINT or DOUBLE
precision, and the rest with DOUBLE precision. You should try to
avoid using unsigned long long values if they resolve to be bigger than
63 bits (9223372036854775807) for anything other than bit fields.
MySQL Server 4.0 has better BIGINT handling than 3.23.
BLOB and TEXT columns, automatically
have all trailing spaces removed when retrieved. For CHAR types, this
is okay. The bug is
that in MySQL Server, VARCHAR columns are treated the same way.
ENUM and SET columns in one table.
MIN(), MAX(), and other aggregate functions, MySQL
currently compares ENUM and SET columns by their string
value rather than by the string's relative position in the set.
mysqld_safe redirects all messages from mysqld to the
mysqld log. One problem with this is that if you execute
mysqladmin refresh to close and reopen the log,
stdout and stderr are still redirected to the old log.
If you use --log extensively, you should edit mysqld_safe to
log to `host_name.err' instead of `host_name.log' so that you can
easily reclaim the space for the old log by deleting the old one and
executing mysqladmin refresh.
UPDATE statement, columns are updated from left to right. If
you refer to an updated column, you get the updated value instead of the
original value. For example, the following statement increments KEY
by 2, not 1:
mysql> UPDATE tbl_name SET KEY=KEY+1,KEY=KEY+1;
mysql> SELECT * FROM temp_table, temp_table AS t2; ERROR 1137: Can't reopen table: 'temp_table'
DISTINCT differently when you are using
``hidden'' columns in a join than when you are not. In a join, hidden
columns are counted as part of the result (even if they are not shown),
whereas in normal queries, hidden columns don't participate in the
DISTINCT comparison. We will probably change this in the future to
never compare the hidden columns when executing DISTINCT.
An example of this is:
SELECT DISTINCT mp3id FROM band_downloads
WHERE userid = 9 ORDER BY id DESC;
and
SELECT DISTINCT band_downloads.mp3id
FROM band_downloads,band_mp3
WHERE band_downloads.userid = 9
AND band_mp3.id = band_downloads.mp3id
ORDER BY band_downloads.id DESC;
In the second case, you might in MySQL Server 3.23.x get two identical rows in
the result set (because the values in the hidden id column may differ).
Note that this happens only for queries where you don't have the
ORDER BY columns in the result.
PROCEDURE on a query that returns an empty set,
in some cases the PROCEDURE will not transform the columns.
MERGE doesn't check whether the underlying
tables are of compatible types.
ALTER TABLE first to add a UNIQUE index to a
table used in a MERGE table and then to
add a normal index on the MERGE table, the key order will be
different for the tables if there was an old key that was not unique in the
table. This is because ALTER TABLE puts UNIQUE indexes before
normal indexes to be able to detect duplicate keys as early as possible.
The following are known bugs in earlier versions of MySQL:
LOCK TABLE with WRITE.
FLUSH TABLES.
UPDATE that updated a key with
a WHERE on the same key may have failed because the key was used to
search for records and the same row may have been found multiple times:
UPDATE tbl_name SET KEY=KEY+1 WHERE KEY > 100;A workaround is to use:
UPDATE tbl_name SET KEY=KEY+1 WHERE KEY+0 > 100;This will work because MySQL Server will not use an index on expressions in the
WHERE clause.
For information about platform-specific bugs, see the installation and porting instructions in section 2.12 Operating System-Specific Notes and section E Porting to Other Systems.
This chapter describes how to obtain and install MySQL:
GnuPG.
Before installing MySQL, you should do the following:
This section contains the information necessary to carry out these steps. After doing so, you can use the instructions in later sections of the chapter to install the distribution that you choose.
This section lists the operating systems on which you can expect to be able to run MySQL.
We use GNU Autoconf, so it is possible to port MySQL to all modern systems that have a C++ compiler and a working implementation of POSIX threads. (Thread support is needed for the server. To compile only the client code, the only requirement is a C++ compiler.) We use and develop the software ourselves primarily on Linux (SuSE and Red Hat), FreeBSD, and Sun Solaris (Versions 8 and 9).
MySQL has been reported to compile successfully on the following combinations of operating system and thread package. Note that for many operating systems, native thread support works only in the latest versions.
glibc 2.0.7+ for various
CPU architectures. See section 2.12.1 Linux Notes.
Not all platforms are equally well-suited for running MySQL. How well a certain platform is suited for a high-load mission-critical MySQL server is determined by the following factors:
pthread_mutex_lock() is too anxious to yield CPU time, this will hurt
MySQL tremendously. If this issue is not taken care of, adding extra CPUs
will actually make MySQL slower.
Based on the preceding criteria, the best platforms for running
MySQL at this point are x86 with SuSE Linux using a 2.4 kernel, and
ReiserFS (or any similar Linux distribution) and SPARC with Solaris
(2.7-9). FreeBSD comes third, but we really hope it will join the top
club once the thread library is improved. We also hope that at some
point we will be able to include into the top category all other platforms
on which MySQL currently compiles and runs okay, but not quite with the
same level of stability and performance. This will require some
effort on our part in cooperation with the developers of the operating system
and library components that MySQL depends on. If you are interested in
improving one of those components, are in a position to influence its
development, and need more detailed instructions on what MySQL
needs to run better, send an email message to the MySQL internals
mailing list.
See section 1.4.1.1 The MySQL Mailing Lists.
Please note that the purpose of the preceding comparison is not to say that one operating system is better or worse than another in general. We are talking only about choosing an OS for the specific purpose of running MySQL. With this in mind, the result of this comparison would be different if we considered more factors. In some cases, the reason one OS is better than the other could simply be that we have been able to put more effort into testing and optimizing for a particular platform. We are just stating our observations to help you decide which platform to use for running MySQL.
When preparing to install MySQL, you should decide which version to use. MySQL development occurs in several release series, and you can pick the one that best fits your needs. After deciding which version to install, you can choose a distribution format. Releases are available in binary or source format.
The first decision to make is whether you want to use a production (stable) release or a development release. In the MySQL development process, multiple release series co-exist, each at a different stage of maturity:
We don't believe in a complete freeze, as this also leaves out bugfixes and things that ``must be done.'' ``Somewhat frozen'' means that we may add small things that ``almost surely will not affect anything that's currently working.'' Naturally, relevant bugfixes from an earlier series propagate to later series.
Normally, if you are beginning to use MySQL for the first time or trying to port it to some system for which there is no binary distribution, we recommend going with the production release series. Currently this is MySQL 4.1. All MySQL releases, even those from development series, are checked with the MySQL benchmarks and an extensive test suite before being issued.
If you are running an old system and want to upgrade, but don't want to take the chance of having a non-seamless upgrade, you should upgrade to the latest version in the same release series you are using (where only the last part of the version number is newer than yours). We have tried to fix only fatal bugs and make small, relatively safe changes to that version.
If you want to use new features not present in the production release series, you can use a version from a development series. Note that development releases are not as stable as production releases.
If you want to use the very latest sources containing all current patches and bugfixes, you can use one of our BitKeeper repositories. These are not ``releases'' as such, but are available as previews of the code on which future releases will be based.
The MySQL naming scheme uses release names that consist of three
numbers and a suffix; for example, mysql-4.1.2-alpha.
The numbers within the release name are interpreted like this:
4) is the major version and also describes the
file format. All Version 4 releases have the same file format.
1) is the release level.
Taken together, the major version and release level constitute the release
series number.
2) is the version number within the
release series. This is incremented for each new release. Usually you
want the latest version for the series you have chosen.
For each minor update, the last number in the version string is incremented. When there are major new features or minor incompatibilities with previous versions, the second number in the version string is incremented. When the file format changes, the first number is increased.
Release names also include a suffix to indicates the stability level of the release. Releases within a series progress through a set of suffixes to indicate how the stability level improves. The possible suffixes are:
alpha indicates that the release contains some large section of
new code that hasn't been 100% tested. Known bugs (usually there are none)
should be documented in the News section. See section D MySQL Change History. There are also new
commands and extensions in most alpha releases. Active development that
may involve major code changes can occur in an alpha release, but everything
will be tested before issuing a release. For this reason, there should be
no known bugs in any MySQL release.
beta means that all new code has been tested. No major new
features that could cause corruption in old code are added. There should
be no known bugs. A version changes from alpha to beta when there
haven't been any reported fatal bugs within an alpha version for at least
a month and we have no plans to add any features that could make any old
command unreliable.
gamma is a beta that has been around a while and seems to work fine.
Only minor fixes are added. This is what many other companies call a release.
MySQL uses a naming scheme that is slightly different from most other products. In general, it's relatively safe to use any version that has been out for a couple of weeks without being replaced with a new version within the release series.
All releases of MySQL are run through our standard tests and benchmarks to ensure that they are relatively safe to use. Because the standard tests are extended over time to check for all previously found bugs, the test suite keeps getting better.
All releases have been tested at least with:
crash-me test
Another test is that we use the newest MySQL version in our internal production environment, on at least one machine. We have more than 100GB of data to work with.
After choosing which version of MySQL to install, you should decide
whether to use a binary distribution or a source distribution. In
most cases, you should probably use a binary distribution, if one
exists for your platform. Binary distributions are available in native format
for many platforms, such as RPM files for Linux or DMG package installers for
Mac OS X. Distributions also are available as Zip archives or compressed
tar files.
Reasons to choose a binary distribution include the following:
-max suffix and is configured with the same options as
mysqld-max. See section 5.1.2 The mysqld-max Extended MySQL Server.
If you want to use the MySQL-Max RPM, you must first
install the standard MySQL-server RPM.
Under some circumstances, you probably will be better off installing MySQL from a source distribution:
mysqld with some extra features that are not
included in the standard binary distributions. Here is a list of the most
common extra options that you may want to use:
--with-innodb (default for MySQL 4.0 and up)
--with-berkeley-db (not available on all platforms)
--with-raid
--with-libwrap
--with-named-z-libs (this is done for some of the binaries)
--with-debug[=full]
mysqld without some features that are
included in the standard binary distributions. For example,
distributions normally are compiled with support for all character
sets. If you want a smaller MySQL server, you can recompile it with support
for only the character sets you need.
pgcc) or want to use compiler
options that are better optimized for your processor. Binary distributions
are compiled with options that should work on a variety of processors from
the same processor family.
MySQL is evolving quite rapidly here at MySQL AB and we want to share new developments with other MySQL users. We try to make a release when we have very useful features that others seem to have a need for.
We also try to help out users who request features that are easy to implement. We take note of what our licensed users want to have, and we especially take note of what our support customers want and try to help them out.
No one has to download a new release. The News section will tell you if the new release has something you really want. See section D MySQL Change History.
We use the following policy when updating MySQL:
We put a lot of time and effort into making our releases bug-free. To our knowledge, we have not released a single MySQL version with any known ``fatal'' repeatable bugs. (A ``fatal'' bug is something that crashes MySQL under normal usage, produces incorrect answers for normal queries, or has a security problem.)
We have documented all open problems, bugs, and issues that are dependent on design decisions. See section 1.5.7 Known Errors and Design Deficiencies in MySQL.
Our aim is to fix everything that is fixable without risk of making a stable MySQL version less stable. In certain cases, this means we can fix an issue in the development versions, but not in the stable (production) version. Naturally, we document such issues so that users are aware of them.
Here is a description of how our build process works:
mysql and announce mailing
lists.
See section 1.4.1.1 The MySQL Mailing Lists.
The announcement message contains a list
of all changes to the release and any known problems with the release.
The Known Problems section in the release notes has been needed
for only a handful of releases.
'a' release for that
platform. Thanks to our large user base, problems are found quickly.
glibc library on one of our build
machines that took us a long time to track down.
As a service of MySQL AB, we provide a set of binary distributions of MySQL that are compiled on systems at our site or on systems where supporters of MySQL kindly have given us access to their machines.
In addition to the binaries provided in platform-specific package formats,
we offer binary distributions for a number of platforms in the form of
compressed tar files (.tar.gz files).
See section 2.2 Standard MySQL Installation Using a Binary Distribution.
For Windows distributions, see section 2.3 Installing MySQL on Windows.
These distributions are generated using the script
Build-tools/Do-compile, which compiles the source code and creates
the binary tar.gz archive using
scripts/make_binary_distribution.
These binaries are configured and built with the following compilers and
options. This information can also be obtained by looking at the variables
COMP_ENV_INFO and CONFIGURE_LINE inside the script
bin/mysqlbug of every binary tar file distribution.
The following binaries are built on MySQL AB development systems:
gcc 2.95.3:
CFLAGS="-O2 -mcpu=pentiumpro" CXX=gcc CXXFLAGS="-O2 -mcpu=pentiumpro -felide-constructors" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --disable-shared --with-client-ldflags=-all-static --with-mysqld-ldflags=-all-static
icc (Intel C++ Compiler 8.0):
CC=icc CXX=icc CFLAGS="-O3 -unroll2 -ip -mp -no-gcc -restrict" CXXFLAGS="-O3 -unroll2 -ip -mp -no-gcc -restrict" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --disable-shared --with-client-ldflags=-all-static --with-mysqld-ldflags=-all-static --with-embedded-server --with-innodb
ecc (Intel C++ Itanium Compiler 7.0):
CC=ecc CFLAGS="-O2 -tpp2 -ip -nolib_inline" CXX=ecc CXXFLAGS="-O2 -tpp2 -ip -nolib_inline" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile
ecc (Intel C++ Itanium Compiler 7.0):
CC=ecc CFLAGS=-tpp1 CXX=ecc CXXFLAGS=-tpp1 ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile
ccc (Compaq C V6.2-505 / Compaq C++ V6.3-006):
CC=ccc CFLAGS="-fast -arch generic" CXX=cxx CXXFLAGS="-fast -arch generic -noexceptions -nortti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-mysqld-ldflags=-non_shared --with-client-ldflags=-non_shared --disable-shared
gcc 2.95.4:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-embedded-server --with-innodb
gcc 2.95.3:
CFLAGS="-O2" CXX=gcc CXXFLAGS="-O2 -felide-constructors" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-client-ldflags=-all-static --with-mysqld-ldflags=-all-static
gcc 3.2.1:
CXX=gcc ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared
gcc 3.2.3:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-innodb
gcc 3.2:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --with-named-z-libs=no --with-named-curses-libs=-lcurses --disable-shared
gcc 3.2:
CC=gcc CFLAGS="-O3 -m64 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -m64 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --with-named-curses-libs=-lcurses --disable-shared
gcc 2.95.3:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --with-named-curses-libs=-lcurses --disable-shared
cc-5.0 (Sun Forte 5.0):
CC=cc-5.0 CXX=CC ASFLAGS="-xarch=v9" CFLAGS="-Xa -xstrconst -mt -D_FORTEC_ -xarch=v9" CXXFLAGS="-noex -mt -D_FORTEC_ -xarch=v9" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --with-named-z-libs=no --enable-thread-safe-client --disable-shared
gcc 3.2.3:
CFLAGS="-O2 -mcpu=powerpc -Wa,-many " CXX=gcc CXXFLAGS="-O2 -mcpu=powerpc -Wa,-many -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --disable-shared
xlC_r (IBM Visual Age C/C++ 6.0):
CC=xlc_r CFLAGS="-ma -O2 -qstrict -qoptimize=2 -qmaxmem=8192" CXX=xlC_r CXXFLAGS ="-ma -O2 -qstrict -qoptimize=2 -qmaxmem=8192" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --disable-shared --with-innodb
gcc 3.3:
CFLAGS="-O2 -mcpu=powerpc -Wa,-many" CXX=gcc CXXFLAGS="-O2 -mcpu=powerpc -Wa,-many -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --disable-shared
xlC_r (IBM Visual Age C/C++ 6.0):
CC=xlc_r CFLAGS="-ma -O2 -qstrict -qoptimize=2 -qmaxmem=8192" CXX=xlC_r CXXFLAGS="-ma -O2 -qstrict -qoptimize=2 -qmaxmem=8192" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --disable-shared --with-embedded-server --with-innodb
gcc 3.1:
CFLAGS="-DHPUX -I/opt/dce/include -O3 -fPIC" CXX=gcc CXXFLAGS="-DHPUX -I/opt/dce /include -felide-constructors -fno-exceptions -fno-rtti -O3 -fPIC" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-pthread --with-named-thread-libs=-ldce --with-lib-ccflags=-fPIC --disable-shared
aCC (HP ANSI C++ B3910B A.03.50):
CC=cc CXX=aCC CFLAGS=+DAportable CXXFLAGS=+DAportable ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-embedded-server --with-innodb
aCC (HP ANSI C++ B3910B A.03.33):
CC=cc CXX=aCC CFLAGS=+DD64 CXXFLAGS=+DD64 ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared
aCC (HP ANSI C++ B3910B A.03.33):
CC=cc CXX=aCC CFLAGS="+DAportable" CXXFLAGS="+DAportable" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-innodb
aCC (HP aC++/ANSI C B3910B A.05.50):
CC=cc CXX=aCC CFLAGS="+DD64 +DSitanium2" CXXFLAGS="+DD64 +DSitanium2" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-embedded-server --with-innodb
gcc 3.1:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared
gcc 2.95.4:
CFLAGS=-DHAVE_BROKEN_REALPATH ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --with-named-z-libs=not-used --disable-shared
gcc 2.95.4:
CFLAGS="-DHAVE_BROKEN_REALPATH -D__USE_UNIX98 -D_REENTRANT -D_THREAD_SAFE -I/usr/local/include/pthread/linuxthreads" CXXFLAGS="-DHAVE_BROKEN_REALPATH -D__USE_UNIX98 -D_REENTRANT -D_THREAD_SAFE -I/usr/local/include/pthread/linuxthreads" ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --enable-thread-safe-client --enable-local-infile --enable-assembler --with-named-thread-libs="-DHAVE_GLIBC2_STYLE_GETHOSTBYNAME_R -D_THREAD_SAFE -I /usr/local/include/pthread/linuxthreads -L/usr/local/lib -llthread -llgcc_r" --disable-shared --with-embedded-server --with-innodb
gcc 2.95.3qnx-nto 20010315:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared
The following binaries are built on third-party systems kindly provided to MySQL AB by other users. These are provided only as a courtesy; MySQL AB does not have full control over these systems, so we can provide only limited support for the binaries built on them.
gcc 2.95.3:
CFLAGS="-O3 -mpentium" LDFLAGS=-static CXX=gcc CXXFLAGS="-O3 -mpentium -felide-constructors" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --enable-thread-safe-client --disable-shared
CC 3.2:
CC=cc CFLAGS="-O" CXX=CC ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-z-libs=no --enable-thread-safe-client --disable-shared
cc/cxx (Compaq C V6.3-029i / DIGITAL C++ V6.1-027):
CC="cc -pthread" CFLAGS="-O4 -ansi_alias -ansi_args -fast -inline speed -speculate all" CXX="cxx -pthread" CXXFLAGS="-O4 -ansi_alias -fast -inline speed -speculate all -noexceptions -nortti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --with-named-thread-libs="-lpthread -lmach -lexc -lc" --disable-shared --with-mysqld-ldflags=-all-static
gcc 3.0.1:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared
gcc 3.2.1:
CFLAGS=-DHAVE_BROKEN_REALPATH ./configure --prefix=/usr/local/mysql --localstatedir=/usr/local/mysql/data --libexecdir=/usr/local/mysql/bin --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --disable-shared --with-innodb
The following compile options have been used for binary packages that MySQL AB provided in the past. These binaries no longer are being updated, but the compile options are listed here for reference purposes.
egcs 1.1.2:
CC=gcc CFLAGS="-O3 -fno-omit-frame-pointer" CXX=gcc CXXFLAGS="-O3 -fno-omit-frame-pointer -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex --enable-thread-safe-client --enable-local-infile --enable-assembler --disable-shared
gcc 2.95.2:
CFLAGS="-O3 -mpentiumpro" CXX=gcc CXXFLAGS="-O3 -mpentiumpro -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --enable-assembler --with-mysqld-ldflags=-all-static --disable-shared --with-extra-charsets=complex
gcc 2.7.2.1:
CC=gcc CXX=gcc CXXFLAGS="-O3 -felide-constructors" ./configure --prefix=/usr/local/mysql --disable-shared --with-extra-charsets=complex --enable-assembler
egcs 1.0.3a or 2.90.27 or
gcc 2.95.2 and newer:
CC=gcc CFLAGS="-O3" CXX=gcc CXXFLAGS="-O3 -felide-constructors -fno-exceptions -fno-rtti" ./configure --prefix=/usr/local/mysql --with-low-memory --with-extra-charsets=complex --enable-assembler
gcc 2.8.1:
CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql --with-low-memory --with-extra-charsets=complex
gcc 2.7.2.1:
CC=gcc CXX=gcc CXXFLAGS=-O ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex
gcc 2.7.2:
CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex
gcc 2.7.2.2:
CC=gcc CXX=gcc CXXFLAGS=-O3 ./configure --prefix=/usr/local/mysql --with-extra-charsets=complex
Anyone who has more optimal options for any of the preceding configurations
listed can always mail them to the MySQL internals mailing list.
See section 1.4.1.1 The MySQL Mailing Lists.
RPM distributions prior to MySQL 3.22 are user-contributed. Beginning with MySQL 3.22, RPM distributions are generated by MySQL AB.
If you want to compile a debug version of MySQL, you should add
--with-debug or --with-debug=full to the preceding
configure commands and remove any -fomit-frame-pointer options.
Check the MySQL downloads page (http://dev.mysql.com/downloads/) for information about the current version and for downloading instructions. For a complete up-to-date list of MySQL download mirror sites, see http://dev.mysql.com/downloads/mirrors.html. There you will also find information about becoming a MySQL mirror site and how to report a bad or out-of-date mirror.
Our main mirror is located at http://mirrors.sunsite.dk/mysql/.
GnuPGAfter you have downloaded the MySQL package that suits your needs and before you attempt to install it, you should make sure that it is intact and has not been tampered with. MySQL AB offers three means of integrity checking:
GnuPG, the GNU Privacy Guard
The following sections describe how to use these methods.
If you notice that the MD5 checksum or GPG signatures do not match, first try to download the respective package one more time, perhaps from another mirror site. If you repeatedly cannot successfully verify the integrity of the package, please notify us about such incidents, including the full package name and the download site you have been using, at webmaster@mysql.com or build@mysql.com. Do not report downloading problems using the bug-reporting system.
After you have downloaded a MySQL package, you should make sure that its MD5
checksum matches the one provided on the MySQL download pages. Each package
has an individual checksum that you can verify with the following command,
where package_name is the name of the package you downloaded:
shell> md5sum package_name
Example:
shell> md5sum mysql-standard-4.0.17-pc-linux-i686.tar.gz 60f5fe969d61c8f82e4f7f62657e1f06 mysql-standard-4.0.17-pc-linux-i686.tar.gz
You should verify that the resulting checksum (the string of hexadecimal digits) matches the one displayed on the download page immediately below the respective package.
Note: Make sure to verify the checksum of the archive file
(e.g. the .zip or .tar.gz file) and not of the files that are
contained inside of the archive!
Note that not all operating systems support the md5sum command. On
some, it is simply called md5 and others do not ship it at all. On
Linux, it is part of the GNU Text Utilities package, which is
available for a wide range of platforms. You can download the source code
from http://www.gnu.org/software/textutils/ as well. If you have
OpenSSL installed, you can also use the command openssl md5
package_name instead. A DOS/Windows implementation of the md5
command line utility is available from http://www.fourmilab.ch/md5/.
A graphical MD5 checking tool is winMd5Sum, which can be obtained
from http://winmd5sum.solidblue.biz/.
GnuPGAnother method of verifying the integrity and authenticity of a package is to use cryptographic signatures. This is more reliable than using MD5 checksums, but requires more work.
Beginning with MySQL 4.0.10 (February 2003), MySQL AB started signing
downloadable packages with GnuPG (GNU Privacy Guard).
GnuPG is an Open Source alternative to the very well-known
Pretty Good Privacy (PGP) by Phil Zimmermann.
See http://www.gnupg.org/ for more information about GnuPG
and how to obtain and install it on your system. Most Linux distributions
ship with GnuPG installed by default. For more information
about OpenPGP, see http://www.openpgp.org/.
To verify the signature for a specific package, you first need to obtain a
copy of MySQL AB's public GPG build key. You can download the key from
http://www.keyserver.net/. The key that you want to obtain is named
build@mysql.com. Alternatively, you can cut and paste the key
directly from the following text:
Key ID:
pub 1024D/5072E1F5 2003-02-03
MySQL Package signing key (www.mysql.com) <build@mysql.com>
Fingerprint: A4A9 4068 76FC BD3C 4567 70C8 8C71 8D3B 5072 E1F5
Public Key (ASCII-armored):
-----BEGIN PGP PUBLIC KEY BLOCK-----
Version: GnuPG v1.0.6 (GNU/Linux)
Comment: For info see http://www.gnupg.org
mQGiBD4+owwRBAC14GIfUfCyEDSIePvEW3SAFUdJBtoQHH/nJKZyQT7h9bPlUWC3
RODjQReyCITRrdwyrKUGku2FmeVGwn2u2WmDMNABLnpprWPkBdCk96+OmSLN9brZ
fw2vOUgCmYv2hW0hyDHuvYlQA/BThQoADgj8AW6/0Lo7V1W9/8VuHP0gQwCgvzV3
BqOxRznNCRCRxAuAuVztHRcEAJooQK1+iSiunZMYD1WufeXfshc57S/+yeJkegNW
hxwR9pRWVArNYJdDRT+rf2RUe3vpquKNQU/hnEIUHJRQqYHo8gTxvxXNQc7fJYLV
K2HtkrPbP72vwsEKMYhhr0eKCbtLGfls9krjJ6sBgACyP/Vb7hiPwxh6rDZ7ITnE
kYpXBACmWpP8NJTkamEnPCia2ZoOHODANwpUkP43I7jsDmgtobZX9qnrAXw+uNDI
QJEXM6FSbi0LLtZciNlYsafwAPEOMDKpMqAK6IyisNtPvaLd8lH0bPAnWqcyefep
rv0sxxqUEMcM3o7wwgfN83POkDasDbs3pjwPhxvhz6//62zQJ7Q7TXlTUUwgUGFj
a2FnZSBzaWduaW5nIGtleSAod3d3Lm15c3FsLmNvbSkgPGJ1aWxkQG15c3FsLmNv
bT6IXQQTEQIAHQUCPj6jDAUJCWYBgAULBwoDBAMVAwIDFgIBAheAAAoJEIxxjTtQ
cuH1cY4AnilUwTXn8MatQOiG0a/bPxrvK/gCAJ4oinSNZRYTnblChwFaazt7PF3q
zIhMBBMRAgAMBQI+PqPRBYMJZgC7AAoJEElQ4SqycpHyJOEAn1mxHijft00bKXvu
cSo/pECUmppiAJ41M9MRVj5VcdH/KN/KjRtW6tHFPYhMBBMRAgAMBQI+QoIDBYMJ
YiKJAAoJELb1zU3GuiQ/lpEAoIhpp6BozKI8p6eaabzF5MlJH58pAKCu/ROofK8J
Eg2aLos+5zEYrB/LsrkCDQQ+PqMdEAgA7+GJfxbMdY4wslPnjH9rF4N2qfWsEN/l
xaZoJYc3a6M02WCnHl6ahT2/tBK2w1QI4YFteR47gCvtgb6O1JHffOo2HfLmRDRi
Rjd1DTCHqeyX7CHhcghj/dNRlW2Z0l5QFEcmV9U0Vhp3aFfWC4Ujfs3LU+hkAWzE
7zaD5cH9J7yv/6xuZVw411x0h4UqsTcWMu0iM1BzELqX1DY7LwoPEb/O9Rkbf4fm
Le11EzIaCa4PqARXQZc4dhSinMt6K3X4BrRsKTfozBu74F47D8Ilbf5vSYHbuE5p
/1oIDznkg/p8kW+3FxuWrycciqFTcNz215yyX39LXFnlLzKUb/F5GwADBQf+Lwqq
a8CGrRfsOAJxim63CHfty5mUc5rUSnTslGYEIOCR1BeQauyPZbPDsDD9MZ1ZaSaf
anFvwFG6Llx9xkU7tzq+vKLoWkm4u5xf3vn55VjnSd1aQ9eQnUcXiL4cnBGoTbOW
I39EcyzgslzBdC++MPjcQTcA7p6JUVsP6oAB3FQWg54tuUo0Ec8bsM8b3Ev42Lmu
QT5NdKHGwHsXTPtl0klk4bQk4OajHsiy1BMahpT27jWjJlMiJc+IWJ0mghkKHt92
6s/ymfdf5HkdQ1cyvsz5tryVI3Fx78XeSYfQvuuwqp2H139pXGEkg0n6KdUOetdZ
Whe70YGNPw1yjWJT1IhMBBgRAgAMBQI+PqMdBQkJZgGAAAoJEIxxjTtQcuH17p4A
n3r1QpVC9yhnW2cSAjq+kr72GX0eAJ4295kl6NxYEuFApmr1+0uUq/SlsQ==
=YJkx
-----END PGP PUBLIC KEY BLOCK-----
You can import the build key into your personal public GPG keyring by using
gpg --import. For example, if you save the key in a file named
`mysql_pubkey.asc', the import command looks like this:
shell> gpg --import mysql_pubkey.asc
See the GPG documentation for more information on how to work with public keys.
After you have downloaded and imported the public build key, download your desired MySQL package and the corresponding signature, which also is available from the download page. The signature file has the same name as the distribution file with an `.asc' extension. For example:
| Distribution file | mysql-standard-4.0.17-pc-linux-i686.tar.gz
|
| Signature file | mysql-standard-4.0.17-pc-linux-i686.tar.gz.asc
|
Make sure that both files are stored in the same directory and then run the following command to verify the signature for the distribution file:
shell> gpg --verify package_name.asc
Example:
shell> gpg --verify mysql-standard-4.0.17-pc-linux-i686.tar.gz.asc
gpg: Warning: using insecure memory!
gpg: Signature made Mon 03 Feb 2003 08:50:39 PM MET
using DSA key ID 5072E1F5
gpg: Good signature from
"MySQL Package signing key (www.mysql.com) <build@mysql.com>"
The Good signature message indicates that everything is all right.
You can ignore the insecure memory warning.
RPMFor RPM packages, there is no separate signature. RPM packages have a built-in GPG signature and MD5 checksum. You can verify a package by running the following command:
shell> rpm --checksig package_name.rpm
Example:
shell> rpm --checksig MySQL-server-4.0.10-0.i386.rpm MySQL-server-4.0.10-0.i386.rpm: md5 gpg OK
Note: If you are using RPM 4.1 and it complains about (GPG)
NOT OK (MISSING KEYS: GPG#5072e1f5), even though you have imported the
MySQL public build key into your own GPG keyring, you need to import the
key into the RPM keyring first. RPM 4.1 no longer uses your personal GPG
keyring (or GPG itself). Rather, it maintains its own keyring because it is
a system-wide application and a user's GPG public keyring is a user-specific
file. To import the MySQL public key into the RPM keyring, first obtain the
key as described in the previous section. Then use rpm --import
to import the key. For example, if you have the public key stored in a file
named `mysql_pubkey.asc', import it using this command:
shell> rpm --import mysql_pubkey.asc
If you need to obtain the MySQL public key, see section 2.1.4.2 Signature Checking Using GnuPG.
This section describes the default layout of the directories created by installing binary or source distributions provided by MySQL AB. If you install a distribution provided by another vendor, some other layout might be used.
On Windows, the default installation directory is `C:\mysql'. With MySQL version 4.1.5 and higher, this has changed to `C:\Program Files\MySQL\MySQL Server 4.1', where 4.1 will be the major version of the installation. The folder has the following subdirectories:
| Directory | Contents of Directory |
| `bin' | Client programs and the mysqld server
|
| `data' | Log files, databases |
| `Docs' | Documentation |
| `examples' | Example programs and scripts |
| `include' | Include (header) files |
| `lib' | Libraries |
| `scripts' | Utility scripts |
| `share' | Error message files |
Installations created from Linux RPM distributions result in files under the following system directories:
| Directory | Contents of Directory |
| `/usr/bin' | Client programs and scripts |
| `/usr/sbin' | The mysqld server
|
| `/var/lib/mysql' | Log files, databases |
| `/usr/share/doc/packages' | Documentation |
| `/usr/include/mysql' | Include (header) files |
| `/usr/lib/mysql' | Libraries |
| `/usr/share/mysql' | Error message and character set files |
| `/usr/share/sql-bench' | Benchmarks |
On Unix, a tar file
binary distribution is installed by unpacking it at the installation
location you choose (typically `/usr/local/mysql') and creates the
following directories in that location:
| Directory | Contents of Directory |
| `bin' | Client programs and the mysqld server
|
| `data' | Log files, databases |
| `docs' | Documentation, ChangeLog |
| `include' | Include (header) files |
| `lib' | Libraries |
| `scripts' | mysql_install_db
|
| `share/mysql' | Error message files |
| `sql-bench' | Benchmarks |
A source distribution is installed after you configure and compile it. By default, the installation step installs files under `/usr/local', in the following subdirectories:
| Directory | Contents of Directory |
| `bin' | Client programs and scripts |
| `include/mysql' | Include (header) files |
| `info' | Documentation in Info format |
| `lib/mysql' | Libraries |
| `libexec' | The mysqld server
|
| `share/mysql' | Error message files |
| `sql-bench' | Benchmarks and crash-me test
|
| `var' | Databases and log files |
Within an installation directory, the layout of a source installation differs from that of a binary installation in the following ways:
mysqld server is installed in the `libexec'
directory rather than in the `bin' directory.
mysql_install_db is installed in the `bin' directory
rather than in the `scripts' directory.
You can create your own binary installation from a compiled source distribution by executing the `scripts/make_binary_distribution' script from the top directory of the source distribution.
The next several sections cover the installation of MySQL on platforms where we offer packages using the native packaging format of the respective platform. (This is also known as performing a ``binary install.'') However, binary distributions of MySQL are available for many other platforms as well. See section 2.7 Installing MySQL on Other Unix-Like Systems for generic installation instructions for these packages that apply to all platforms.
See section 2.1 General Installation Issues for more information on what other binary distributions are available and how to obtain them.
A native Windows version of MySQL has been available from MySQL AB since version 3.21 and represents a sizable percentage of the daily downloads of MySQL. This section describes the process for installing MySQL on Windows.
With the release of MySQL 4.1.5, MySQL AB has introduced a new installer for the Windows version of MySQL, combined with a new GUI Configuration Wizard. This combination automatically installs MySQL, creates an option file, starts the server, and secures the default user accounts.
If you have installed a version of MySQL prior to version 4.1.5, you must perform the following steps:
This process also must be followed with newer MySQL installations where the installation package does not include an installer.
MySQL for Windows is available in two distribution formats:
Generally speaking, you should use the binary distribution. It's simpler, and you need no additional tools to get MySQL up and running.
This section describes how to install MySQL on Windows using a binary distribution. To install using a source distribution, see section 2.8.6 Installing MySQL from Source on Windows.
To run MySQL on Windows, you need the following:
You may also have the following optional requirements:
MAX_ROWS and
AVG_ROW_LENGTH when you create tables.
See section 13.2.6 CREATE TABLE Syntax.
Starting with MySQL version 4.1.5, there are three install packages to choose from when installing MySQL on Windows. The Packages are as follows:
The Essentials package is recommended for most users.
Your choice of install package affects the installation process you must follow. If you choose to install either the Essentials or Complete install packages, see section 2.3.3 Installing MySQL with the Automated Installer. If you choose to install MySQL from the Noinstall archive, see section 2.3.6 Installing MySQL from a noinstall Zip Archive.
Starting with MySQL 4.1.5, users can use the new MySQL Installation Wizard and MySQL Configuration Wizard to install MySQL on Windows. The MySQL Installation Wizard and MySQL Configuration Wizard are designed to install and configure MySQL in such a way that new users can immediately get started using MySQL.
The MySQL Installation Wizard and MySQL Configuration Wizard are available in the Essentials and Complete install packages, and are recommended for most standard MySQL installations. Exceptions include users who need to install multiple instances of MySQL on a single server and advanced users who want complete control of server configuration.
If you are installing a version of MySQL prior to MySQL 4.1.5, please follow the instructions for installing MySQL from the Noinstall installation package. See section 2.3.6 Installing MySQL from a noinstall Zip Archive.
MySQL Installation Wizard is a new installer for the MySQL server that uses the latest installer technologies for Microsoft Windows. The MySQL Installation Wizard, in combination with the MySQL Configuration Wizard, allows a user to install and configure a MySQL server that is ready for use immediately after installation.
The MySQL Installation Wizard is the standard installer for all MySQL server distributions, version 4.1.5 and higher. Users of previous versions of MySQL need to manually shut down and remove their existing MySQL installations before installing MySQL with the MySQL Installation Wizard. See section 2.3.4.7 Upgrading MySQL for more information on upgrading from a previous version.
Microsoft has included an improved version of their Microsoft Windows Installer (MSI) in the recent versions of Windows. Using the MSI has become the de-facto standard for application installations on Windows 2000, Windows XP, and Windows Server 2003. The MySQL Installation Wizard makes use of this technology to provide a smoother and more flexible installation progress.
The Microsoft Windows Installer Engine was updated with the release of Windows XP; those using a previous version of Windows can reference this Microsoft Knowledge Base article for information on upgrading to the latest version of the Windows Installer Engine.
Further, Microsoft has introduced the WiX (Windows Installer XML) tool set recently. It is the first highly acknowledged Open Source project from Microsoft. We switched to WiX because it is an Open Source project and it allows us to handle the complete Windows installation process in a flexible way with scripts.
Improving the MySQL Installation Wizard depends on the support and feedback of users like you. If you find that the MySQL Installation Wizard is lacking some feature important to you, or if you discover a bug, please use our MySQL Bug System to request features or report problems.
The MySQL server install packages can be downloaded from http://dev.mysql.com/downloads/. If the package you download is contained within a Zip archive, you need to extract the archive first.
The process for starting the wizard depends on the contents of the
install package you download. If there is a
setup.exe file present, double-click it to start
the install process. If there is a .msi file
present, double-click it to start the install process.
There are up three installation types available:
Typical, Complete, and
Custom.
The Typical installation type installs the MySQL
server, the mysql command-line client, and the
command-line utilities. The command-line clients and utilities
include mysqldump, myisamchk,
and several other tools to help you manage the MySQL server.
The Complete installation type installs all
components included in the installation package. The full
installation package includes components such as the embedded server
library, the benchmark suite, support scripts, and documentation.
The Custom installation type gives you complete
control over which packages you wish to install and the installation
path that will be used. See
section 2.3.4.4 The Custom Install Dialog
for more information on performing a custom install.
If you choose the Typical or
Complete installation types and click the
Next button, you advance to the confirmation
screen to confirm your choices and begin the installation. If you
choose the Custom installation type and click the
Next button, you advance to the custom install
dialog, described in
section 2.3.4.4 The Custom Install Dialog
If you wish to change the installation path or the specific
components that are installed by the MySQL Installation Wizard, you should
choose the Custom installation type.
All available components are listed in a tree view on the left side
of the custom install dialog. Components that will not be installed
have a red X icon, components that will be
installed have a gray icon. To change whether a component is
installed, click on the component's icon and choose an new option
from the drop-down list that appears.
You can change the default installation path by clicking the Change... button to the right of the displayed installation path.
After choosing your install components and installation path, click the Next button to advance to the confirmation dialog.
Once you choose an installation type and optionally choose your installation components, you advance to the confirmation dialog. Your installation type and installation path are displayed for you to review.
To install MySQL if you are satisfied with your settings, click the Install button. To change your settings, click the Back button. To exit the MySQL Installation Wizard without installing MySQL, click the Cancel button.
After installation is complete, you will be given the option of registering with the MySQL web site. Registration will give you access to post in the MySQL forums at forums.mysql.com, along with the ability to report bugs at bugs.mysql.com and subscribe to the newsletter. The final screen of the installer provides a summary of the installation and gives you the option to launch the MySQL Configuration Wizard, which you can use to create a configuration file, install the MySQL service, and configure security.
Once you click the Install button, the MySQL Installation Wizard begins the installation process and makes certain changes to your system which are described in the sections that follow.
Changes to the Registry
The MySQL Installation Wizard creates one Windows registry key in a typical
install situation, located in
HKEY_LOCAL_MACHINE\SOFTWARE\MySQL AB.
The MySQL Installation Wizard creates a key named after the major version of
the server that is being installed, such as MySQL Server
4.1. It contains two string values,
Location and Version. The
Location string contains the path to the
installation directory. In a default installation it contains
C:\Program Files\MySQL\MySQL Server 4.1\. The
Version string contains the release number. For
example, for an installation of MySQL Server 4.1.5 the key contains
a value of 4.1.5.
These registry keys are used to help external tools identify the
installed location of the MySQL server, preventing a complete scan
of the hard-disk to determine the installation path of the MySQL
server. The registry keys are not required to run the server and
when using the noinstall Zip archive the registry
keys are not created.
Changes to the Start Menu
The MySQL Installation Wizard creates a new entry in the Windows Start menu under a common MySQL menu heading named after the major version of MySQL that you have installed. For example, if you install MySQL 4.1, the MySQL Installation Wizard creates a MySQL Server 4.1 section in the start menu.
The following entries are created within the new Start menu section:
MySQL Command Line Client: This is a shortcut to
the mysql command-line client and is configured
to connect as the root user. The shortcut prompts for a root user
password when connecting.
MySQL Server Instance Config Wizard: This is a
shortcut to the MySQL Configuration Wizard. Use this shortcut to configure a
newly installed server, or to re-configure an existing server.
MySQL Documentation: This is a link to the MySQL
server documentation that is stored locally in the MySQL server
installation directory. This option is not available when the MySQL
server is installed from the essential
installation package.
Changes to the File System
The MySQL Installation Wizard by default installs the MySQL server to
C:\Program Files\MySQL\MySQL
Server 4.1, where
Program Files is the default location for
applications in your system, and 4.1 is
the major version of your MySQL server. This is the new recommended
location for the MySQL server, replacing the previous default
location of `c:\mysql'.
By default, all MySQL applications are stored in a common directory
at C:\Program
Files\MySQL, where Program
Files is the default location for applications in your
Windows installation. A typical MySQL installation on a developer
machine may look like this:
C:\Program Files\MySQL\MySQL Server 4.1 C:\Program Files\MySQL\MySQL Server 5.0 C:\Program Files\MySQL\MySQL Administrator 1.0 C:\Program Files\MySQL\MySQL Query Browser 1.0
This approach makes it easier to manage and maintain all MySQL applications installed on a particular system.
From MySQL version 4.1.5, the new MySQL Installation Wizard can perform server upgrades automatically using the upgrade capabilities of MSI. That means you do not need to remove a previous installation manually before installing a new release. The installer automatically shuts down and removes the previous MySQL service before installing the new version.
Automatic upgrades are only available when upgrading between installations that have the same major and minor version numbers. For example, you can upgrade automatically from MySQL 4.1.5 to MySQL 4.1.6, but not from MySQL 4.1 to MySQL 5.0.
If you are upgrading MySQL version 4.1.4 or earlier to version 4.1.5 or later, you must first manually shut down and remove the older installation before upgrading. Be sure to back up your databases before performing such an upgrade, so that you can restore the databases after the upgrade is completed. It is always recommended that you back up your data before performing any upgrades.
See section 2.3.15 Upgrading MySQL on Windows.
The MySQL Configuration Wizard helps automate the process of configuring your server under Windows. The MySQL Configuration Wizard creates a custom `my.ini' file by asking you a series of questions and then applying your responses to a template to generate a `my.ini' file that is tuned to your installation.
The MySQL Configuration Wizard is included with the MySQL server starting with MySQL version 4.1.5, but is designed to work with MySQL servers versions 4.0 and higher. The MySQL Configuration Wizard is currently available for Windows users only.
MySQL Configuration Wizard is to a large extent the result of feedback MySQL AB has received from many users over a period of several years. However, if you find it's lacking some feature important to you, or if you discover a bug, please use our MySQL Bug System to request features or report problems.
The MySQL Configuration Wizard is typically launched from the MySQL Installation Wizard,
as the MySQL Installation Wizard exits. You can also launch the
MySQL Configuration Wizard by clicking the MySQL Server Instance Config
Wizard entry in the MySQL section of the
Start menu.
In addition, you can navigate to the bin directory
of your MySQL installation and launch the
`MySQLInstanceConfig.exe' file directly.
If the MySQL Configuration Wizard detects an existing `my.ini' file, you will have the option of either re-configuring your existing server, or removing the server instance by deleting the `my.ini' file and stopping and removing the MySQL service.
To reconfigure an existing server, choose the Re-configure
Instance option and click the Next
button. Your existing `my.ini' file will be
renamed to my
timestamp.ini.bak, where
timestamp is the date and time the
existing `my.ini' file was created. To remove the
existing server instance, choose the Remove
Instance option and click the Next
button.
If you choose the Remove Instance option, you
advance to a confirmation window. Click the
Execute button and the MySQL Configuration Wizard will
stop and remove the MySQL service and delete the
`my.ini' file. The server installation and its
data folder will not be removed.
If you choose the Re-configure Instance option,
you advance to the Configuration Type dialog where
you can choose the type of installation you wish to configure.
When you start the MySQL Configuration Wizard for a new MySQL installation, or
choose the Re-configure Instance option for an
existing installation, you advance to the Configuration
Type dialog.
There are two configuration types available: Detailed
Configuration and Standard
Configuration. The Standard
Configuration option is intended for new users who want to
get started with MySQL quickly without having to make a lot of
decisions in regards to server configuration. The Detailed
Configuration option is intended for advanced users who
want more fine-grained control of server configuration.
If you are new to MySQL and need a server configured as a
single-user developer machine the Standard
Configuration will suit your needs. Choosing the
Standard Configuration option causes the
MySQL Configuration Wizard to automatically set all configuration options with
the exception of the Service Options and
Security Options.
The Standard Configuration sets options that may
be incompatible with systems where there are existing MySQL
installations. If you have an existing MySQL installation on your
system in addition to the installation you wish to configure, the
Detailed Configuration option is recommended.
To complete the Standard Configuration, please refer to the sections
on Service Options and Security Options, located at
section 2.3.5.11 The Service Options Dialog and section 2.3.5.12 The Security Options Dialog
respectively.
There are three different server types available to choose from, and the server type you choose will affect the decisions the MySQL Configuration Wizard makes with regards to memory, disk, and processor usage.
Developer Machine: Choose this option for a
typical desktop workstation where MySQL is intended only for
personal use. It is assumed that many other desktop applications
will be running. The MySQL server will be configured to use minimal
system resources.
Server Machine: Choose this option for a server
machine where the MySQL server will be running alongside other
server applications such as FTP, email, and web servers. The MySQL
server will be configured to use a medium portion of the system
resources.
Dedicated MySQL Server Machine: Choose this
option for a server machine that is intended to run only the MySQL
server. It is assumed that no other applications will be running.
The MySQL server will be configured to use all available system
resources.
The Database Usage dialog allows you to indicate
the table handlers you expect to use when creating MySQL tables. The
option you choose will determine whether the InnoDB table handler is
available and what percentage of the server resources are available
to InnoDB.
Multifunctional Database: This option enables
both the InnoDB and MyISAM table handlers and divides resources
evenly between the two. This option is recommended for users that
will use both table handlers on a regular basis.
Transactional Database Only: This option enables
both the InnoDB and MyISAM table handlers but dedicates most server
resources toward the InnoDB table handler. This option is
recommended for users that will use InnoDB almost exclusively and
will make only minimal use of MyISAM.
Non-Transactional Database Only: This option
disables the InnoDB table handler completely and dedicates all
server resources to the MyISAM table handler. This option is
recommended for users who will not be using InnoDB.
Some users may want to locate the InnoDB tablespace files in a different location than the MySQL server data directory. Placing the tablespace files in a separate location can be desirable if your system has a higher capacity or higher performance storage device available, such as a RAID storage system.
To change the default location for the InnoDB tablespace files, choose a new drive from the drop-down list of drive letters and choose a new path from the drop-down list of paths. To create a custom path, click the ... button.
If you are modifying the configuration of an existing server, you must click the Modify button before you change the path. In this situation you will have to manually move the existing tablespace files to the new location before starting the server.
It is important to set a limit to the number of concurrent
connections to the MySQL server that can be established to prevent
the server from running out of resources. The Concurrent
Connections dialog allows you to choose the expected usage
of your server, and will set the limit for concurrent connections
accordingly. It is also possible to manually set the concurrent
connection limit.
Decision Support (DSS)/OLAP: Choose this option
if your server will not require a large number of concurrent
connections. The maximum number of connections will be set at 100,
with an average of 20 concurrent connections assumed.
Online Transaction Processing (OLTP): Choose this
option if your server will require a large number of concurrent
connections. The maximum number of connections will be set at 500.
Manual Setting: Choose this option to manually
set the maximum number of concurrent connections to the server.
Choose the number of concurrent connections from the drop-down box
provided, or type the maximum number of connections into the
drop-down box if the number you desire is not listed.
Use the Networking Options dialog to enable or
disable TCP/IP networking and to configure the port number that is
used to connect to the MySQL server.
TCP/IP networking is enabled by default. To disable TCP/IP
networking, uncheck the box next to the Enable TCP/IP
Networking option.
Port 3306 is used by default. To change the port used to access MySQL, choose a new port number from the drop-down box or type a new port number directly into the drop-down box. If the port number you choose is in use you will be prompted to confirm your choice of port number.
The MySQL server supports multiple character sets and it is possible
to set a default server character set that will be applied to all
tables, columns, and databases unless overridden. Use the
Character Set dialog to change the default
character set of the MySQL server.
Standard Character Set: Choose this option if you
want to use Latin1 as the default server
character set. Latin1 is used for English and
many Western European languages.
Best Support For Multilingualism: Choose this
option if you want to use UTF8 as the default
server character set. UTF8 can store characters
from many different languages in a single character set.
Manual Selected Default Character Set /
Collation: Choose this option if you want to pick the
server's default character set manually. Choose the desired
character set from the provided drop-down list.
On Windows NT based platforms, the MySQL server can be installed as a service. When installed as a service, the MySQL server can be started automatically during system startup, and even restarted automatically by Windows in the event of a service failure.
The MySQL Configuration Wizard will install the MySQL server as a service by
default, using the service name MySQL. If you do
not wish to install the service, un-check the box next to the
Install As Windows Service option. You can changed
the service name by picking a new service name from the drop-down box
provided or by typing a new service name into the drop-down box.
To install the MySQL server as a service but not have it started
automatically at startup, un-check the box next to the
Launch the MySQL Server automatically option.
It is strongly recommended that you set a root password for your
MySQL server, and the MySQL Configuration Wizard requires you set a root
password by default. If you do not wish to set a root password,
un-check the box next to the Modify Security
Settings option.
To set the root password, type the desired password into both the
New root password and Confirm
boxes. If you are re-configuring an existing server, you will also
need to enter the existing root password into the Current
root password box.
To prevent root logins from across the network, check the box next to
the Root may only connect from localhost option.
This will increase the security of your root account.
To create an anonymous user account, check the box next to the
Create An Anonymous Account option. Creating an
anonymous account can decrease server security and cause login and
permission difficulties and is not recommended.
The final dialog in the MySQL Configuration Wizard is the Confirmation
Dialog. To start the configuration process, click the
Execute button. To return to a previous
dialog, click the Back button. To exit the
MySQL Configuration Wizard without configuring the server, click the
Cancel button.
After you click the Execute button, the MySQL Configuration Wizard will perform a series of tasks with progress displayed onscreen as the tasks are performed.
The MySQL Configuration Wizard will first determine various configuration file options based on your choices using a template prepared by MySQL AB developers and engineers. This template is named `my-template.ini' and is located in your server installation directory.
The MySQL Configuration Wizard will then write these options to a
`my.ini' file. The final location of the
`my.ini' file will be displayed next to the
Write configuration file task.
If you chose to create a service for the MySQL server the MySQL Configuration Wizard will create the service and start it. If you are re-configuring an existing service, the MySQL Configuration Wizard will restart the service to apply your configuration changes.
If you chose to set a root password, the MySQL Configuration Wizard will connect
to the server and set your new root password and apply any other
security setting you may have selected.
After the MySQL Configuration Wizard has completed its tasks, a summary will be shown. Click the Finish button to exit the MySQL Configuration Wizard.
In MySQL installations prior to version 4.1.5 it was customary to name the server configuration file `my.cnf' or `my.ini' and locate the file either at `c:\my.cnf' or `c:\Windows\my.ini'.
The new MySQL Configuration Wizard places the `my.ini' file in the installation directory of the MySQL server. This helps associate configuration files with particular server instances.
To ensure that the MySQL server knows where to look for the
`my.ini' file, an argument similar to this is
passed to the MySQL server as part of the service installation:
--defaults-file="C:\Program Files\MySQL\MySQL
Server 4.1\my.ini", where
C:\Program Files\MySQL\MySQL Server 4.1 is
replaced with the installation path to the MySQL Server.
The --defaults-file instructs the MySQL server to
read the specified file for configuration options.
To modify the `my.ini' file, open it with a text editor and make any necessary changes. You can also modify the server configuration with the MySQL Administrator utility.
MySQL clients and utilities such as the mysql
command-line client and mysqldump will not locate
the `my.ini' file located in the server
installation directory. To configure the client and utility
applications, create a new `my.ini' file in the
`c:\Windows' directory.
Users who are installing from the Noinstall package, or who are installing a version of MySQL prior to 4.1.5 can use the instructions in this section to manually install MySQL. If you are installing a version prior to 4.1.5 with an install package that includes a Setup program, substitute running the Setup program for extracting the archive.
The process for installing MySQL from a Zip archive is as follows:
This process is described in the sections that follow.
To install MySQL manually, do the following:
If you need to specify startup options when you run the server, you can indicate them on the command line or place them in an option file. For options that will be used every time the server starts, you will find it most convenient to use an option file to specify your MySQL configuration. This is true particularly under the following circumstances:
InnoDB
transactional tables in MySQL 3.23, you must manually add some extra lines
to the option file, as described in section 15.4 InnoDB Configuration. (As of MySQL 4.0, InnoDB creates its
data files and log files in the data directory by default. This means you
need not configure InnoDB explicitly. You may still do so if you
wish, and an option file will be useful in this case, too.)
When the MySQL server starts on Windows, it looks for options in
two files: the `my.ini' file in the Windows directory, and
the `C:\my.cnf' file. The Windows directory typically is
named something like `C:\WINDOWS' or `C:\WinNT'. You
can determine its exact location from the value of the WINDIR
environment variable using the following command:
C:\> echo %WINDIR%
MySQL looks for options first in the `my.ini' file, then in
the `my.cnf' file. However, to avoid confusion, it's best if
you use only one file. If your PC uses a boot loader where the
C: drive isn't the boot drive, your only option is to use
the `my.ini' file. Whichever option file you use, it must be a plain
text file.
You can also make use of the example option files included with your MySQL distribution. Look in your install directory for files such as my-small.cnf, my-medium.cnf, my-large.cnf, etc., which you can rename and copy to the appropriate location for use as a base configuration file.
An option file can be created and modified with any text editor,
such as the Notepad program. For example, if MySQL is
installed at `E:\mysql' and the data directory is located at
`E:\mydata\data', you can create the option file and set up
a [mysqld] section to specify values for the basedir
and datadir parameters:
[mysqld] # set basedir to your installation path basedir=E:/mysql # set datadir to the location of your data directory datadir=E:/mydata/data
Note that Windows pathnames are specified in option files using forward slashes rather than backslashes. If you do use backslashes, you must double them:
[mysqld] # set basedir to your installation path basedir=E:\\mysql # set datadir to the location of your data directory datadir=E:\\mydata\\data
On Windows, the MySQL installer places the data directory directly under the directory where you install MySQL. If you would like to use a data directory in a different location, you should copy the entire contents of the `data' directory to the new location. For example, by default, the installer places MySQL in `C:\mysql' and the data directory in `C:\mysql\data'. If you want to use a data directory of `E:\mydata', you must do two things:
--datadir option to specify the new data directory location
each time you start the server.
Starting with MySQL 3.23.38, the Windows distribution includes both the normal and the MySQL-Max server binaries.
Up through the early releases of MySQL 4.1, the servers included in Windows distributions are named like this:
| Binary | Description |
mysqld | Compiled with full debugging and automatic memory allocation checking, symbolic links, and InnoDB and BDB tables.
|
mysqld-opt | Optimized binary. From version 4.0 on, InnoDB is enabled. Before 4.0, this server includes no transactional table support.
|
mysqld-nt | Optimized binary for Windows NT, 2000, and XP with support for named pipes. |
mysqld-max | Optimized binary with support for symbolic links, and InnoDB and BDB tables.
|
mysqld-max-nt | Like mysqld-max, but compiled with support for named pipes.
|
We have found that the server with the most generic name
(mysqld) is the one that many users are likely to choose
by default. However, that is also the server that results in the
highest memory and CPU use due to the inclusion of full debugging
support. The server named mysqld-opt is a better general-use
server choice to make instead if you don't need debugging support
and don't want the maximal feature set offered by the -max
servers or named pipe support offered by the -nt servers.
To make it less likely that the debugging server would be chosen
inadvertently, some name changes were made from MySQL 4.1.2 to
4.1.4: mysqld has been renamed to mysqld-debug
and mysqld-opt has been renamed to mysqld.
Thus, the server that includes debugging support indicates that in
its name, and the server named mysqld is an efficient
default choice. The other servers still have their same names. The
resulting servers are named like this:
| Binary | Description |
mysqld-debug | Compiled with full debugging and automatic memory allocation checking, symbolic links, and InnoDB and BDB tables.
|
mysqld | Optimized binary with InnoDB support.
|
mysqld-nt | Optimized binary for Windows NT, 2000, and XP with support for named pipes. |
mysqld-max | Optimized binary with support for symbolic links, and InnoDB and BDB tables.
|
mysqld-max-nt | Like mysqld-max, but compiled with support for named pipes.
|
The name changes were not both instituted at the same time. If you
have MySQL 4.1.2 or 4.1.3, it might be that you have a server named
mysqld-debug but not one named mysqld. In this
case, you should have a server mysqld-opt, which you
should choose as your default server unless you need maximal features,
named pipes, or debugging support.
All of the preceding binaries are optimized for modern Intel processors, but should work on any Intel i386-class or higher processor.
MySQL supports TCP/IP on all Windows platforms. The mysqld-nt
and mysql-max-nt servers support named pipes on Windows NT, 2000, XP, and 2003.
However, the default is to use TCP/IP regardless of the platform.
(Named pipes are slower than TCP/IP in many Windows configurations.)
Named pipe use is subject to these conditions:
--enable-named-pipe option.
It is necessary to use this option explicitly because some users have
experienced problems shutting down the MySQL server when named pipes
were used.
mysqld-nt or
mysqld-max-nt servers, and only if the server is run on a version
of Windows that supports named pipes (NT, 2000, XP, 2003).
Note:
Most of the examples in reference manual use mysqld as the
server name. If you choose to use a different server, such as
mysqld-nt, make the appropriate substitutions in the commands that
are shown in the examples.
On Windows 95, 98, or Me, MySQL clients always connect to the server using TCP/IP. (This allows any machine on your network to connect to your MySQL server.) Because of this, you must make sure that TCP/IP support is installed on your machine before starting MySQL. You can find TCP/IP on your Windows CD-ROM.
Note that if you are using an old Windows 95 release (for example, OSR2), it's likely that you have an old Winsock package; MySQL requires Winsock 2! You can get the newest Winsock from http://www.microsoft.com/. Windows 98 has the new Winsock 2 library, so it is unnecessary to update the library.
On NT-based systems such as Windows NT, 2000, XP, or 2003, clients have two options. They can use TCP/IP, or they can use a named pipe if the server supports named pipe connections.
In MySQL versions 4.1 and higher, Windows servers also support shared-memory
connections if started with the --shared-memory option. Clients can
connect through shared memory by using the --protocol=memory option.
For information about which server binary to run, see section 2.3.9 Selecting a MySQL Server type.
This section gives a general overview of starting the MySQL server. The following sections provide more specific information for starting the MySQL server from the command line or as a Windows service.
The examples in these sections assume that MySQL is installed under the default location of `C:\mysql'. Adjust the pathnames shown in the examples if you have MySQL installed in a different location.
Testing is best done from a command prompt in a console window (a ``DOS window''). This way you can have the server display status messages in the window where they are easy to see. If something is wrong with your configuration, these messages make it easier for you to identify and fix any problems.
To start the server, enter this command:
C:\> C:\mysql\bin\mysqld --console
For servers that include InnoDB support,
you should see the following messages as the server starts:
InnoDB: The first specified datafile c:\ibdata\ibdata1 did not exist: InnoDB: a new database to be created! InnoDB: Setting file c:\ibdata\ibdata1 size to 209715200 InnoDB: Database physically writes the file full: wait... InnoDB: Log file c:\iblogs\ib_logfile0 did not exist: new to be created InnoDB: Setting log file c:\iblogs\ib_logfile0 size to 31457280 InnoDB: Log file c:\iblogs\ib_logfile1 did not exist: new to be created InnoDB: Setting log file c:\iblogs\ib_logfile1 size to 31457280 InnoDB: Log file c:\iblogs\ib_logfile2 did not exist: new to be created InnoDB: Setting log file c:\iblogs\ib_logfile2 size to 31457280 InnoDB: Doublewrite buffer not found: creating new InnoDB: Doublewrite buffer created InnoDB: creating foreign key constraint system tables InnoDB: foreign key constraint system tables created 011024 10:58:25 InnoDB: Started
When the server finishes its startup sequence, you should see something like this, which indicates that the server is ready to service client connections:
mysqld: ready for connections Version: '4.0.14-log' socket: '' port: 3306
The server will continue to write to the console any further diagnostic output it produces. You can open a new console window in which to run client programs.
If you omit the --console option, the server writes diagnostic output
to the error log in the data directory (`C:\mysql\data' by default).
The error log is the file with the `.err' extension.
Note: The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in section 2.9 Post-Installation Setup and Testing.
The MySQL server can be started manually from the command line. This can be done on any version of Windows.
To start the mysqld server from the command line, you should
start a console window (a ``DOS window'') and enter this command:
C:\> C:\Program Files\MySQL\MySQL Server 4.1\bin\mysqld
The path used in the preceding example may vary depending on the install location of MySQL on your system.
On non-NT versions of Windows, this will start mysqld in the
background. That is, after the server starts, you should see another
command prompt. If you start the server this way on Windows NT, 2000, or XP,
the server will run in the foreground and no command prompt will appear
until the server exits. Because of this, you should open another console
window to run client programs while the server is running.
You can stop the MySQL server by executing this command:
C:\> C:\Program Files\MySQL\MySQL Server 4.1\bin\mysqladmin -u root shutdown
This invokes the MySQL administrative utility mysqladmin to
connect to the server and tell it to shut down. The command connects
as root, which is the default administrative account in the
MySQL grant system. Note that users in the MySQL grant system
are wholly independent from any login users under Windows.
If mysqld doesn't start, check the error log to see whether the
server wrote any messages there to indicate the cause of the problem.
The error log is located in the `C:\mysql\data' directory. It is
the file with a suffix of `.err'. You can also try to start the
server as mysqld --console; in this case, you may get some useful
information on the screen that may help solve the problem.
The last option is to start mysqld with --standalone
--debug. In this case, mysqld writes a log file
`C:\mysqld.trace' that should contain the reason why mysqld
doesn't start. See section E.1.2 Creating Trace Files.
Use mysqld --verbose --help to display all the options that
mysqld understands. (Prior to MySQL 4.1, omit the
--verbose option.)
On the NT family (Windows NT, 2000, XP, 2003), the recommended way to run
MySQL is to install it as a Windows service. When MySQL is installed as a
service, Windows starts and stops the MySQL server automatically when
Windows starts and stops. A server installed as a service can also be
controlled from the command line using NET commands, or with the
graphical Services utility.
The Services utility (the Windows Service Control Manager) can
be found in the Windows Control Panel (under Administrative
Tools on Windows 2000, XP, and Server 2003). It is advisable to close the
Services utility while performing server installation or removal
operations from this command line. This prevents some odd errors.
To get MySQL to work with TCP/IP on Windows NT 4, you must install service pack 3 (or newer).
Before installing MySQL as a Windows service, you should first stop the current server if it is running by using the following command:
C:\> C:\mysql\bin\mysqladmin -u root shutdown
This invokes the MySQL administrative utility mysqladmin to
connect to the server and tell it to shut down. The command connects
as root, which is the default administrative account in the
MySQL grant system. Note that users in the MySQL grant system
are wholly independent from any login users under Windows.
Install the server as a service:
C:\> mysqld --install
If you have problems installing mysqld as a
service using just the server name, try installing it using its full pathname:
C:\> C:\mysql\bin\mysqld --install
As of MySQL 4.0.2, you can specify a specific service name after the
--install option. As of MySQL 4.0.3, you can in addition specify a
--defaults-file option after the service name to indicate where the
server should obtain options when it starts. The rules that determine the
service name and option files the server uses are as follows:
MySQL, the server uses
the default service name of MySQL and the reads options from
the [mysqld] group in the standard option files.
MySQL after the
--install option, the server reads options from the group that has
the same name as the service. The server reads options from the standard
option files.
As of MySQL 4.0.17, the server also reads options from the [mysqld]
group from the standard option files. This allows you to use the
[mysqld] group for options that should be used by all MySQL services,
and an option group named after each service for use by the server installed
with that service name.
--defaults-file option after the service name,
the server ignores the standard option files and reads options only from the
[mysqld] group of the named file.
Note: Prior to MySQL 4.0.17, a server installed as a Windows service has problems starting if its pathname or the service name contains spaces. For this reason, with older versions, avoid installing MySQL in a directory such as `C:\Program Files' or using a service name containing spaces.
As a more complex example, consider the following command:
C:\> C:\mysql\bin\mysqld --install MySQL --defaults-file=C:\my-opts.cnf
Here, the default service name (MySQL) is given after the
--install option. If no --defaults-file option had been given,
this command would have the effect of causing the server to read the
[mysqld] group from the standard option files. However, because the
--defaults-file option is present, the server reads options from the
[mysqld] option group, but only from the named file.
You can also specify options as ``Start parameters'' in the
Windows Services utility before you start the MySQL service.
Once a MySQL server is installed as a service, Windows will start
the service automatically whenever Windows starts. The service also
can be started immediately from the Services utility, or by
using the command NET START MySQL. The NET command
is not case sensitive.
When run as a service, mysqld has no access
to a console window, so no messages can be seen there. If
mysqld doesn't start, check the error log to see whether the
server wrote any messages there to indicate the cause of the problem.
The error log is located in the `C:\mysql\data' directory. It
is the file with a suffix of `.err'.
When mysqld is running as a service, it can be stopped by
using the Services utility, the command NET STOP
MySQL, or the command mysqladmin shutdown. If the service
is running when Windows shuts down, Windows will stop the server
automatically.
From MySQL 3.23.44 on, you have the choice of installing the
server as a Manual service if you don't wish the service to
be started automatically during the boot process. To do this, use
the --install-manual option rather than the --install
option:
C:\> C:\mysql\bin\mysqld --install-manual
To remove a server that is installed as a service, first stop it if it is
running. Then use the --remove option to remove it:
C:\> C:\mysql\bin\mysqld --remove
For MySQL versions older than 3.23.49, one problem with automatic
MySQL service shutdown is that Windows waited only for a few
seconds for the shutdown to complete, then killed the database
server process if the time limit was exceeded. This had the potential
to cause problems. (For example, the InnoDB storage engine
had to perform crash recovery at the next startup.) Starting from
MySQL 3.23.49, Windows waits longer for the MySQL server
shutdown to complete. If you notice this still is not enough for
your installation, it is safest not to run the MySQL server as a
service. Instead, start it from the command-line prompt, and stop
it with mysqladmin shutdown.
This change to tell Windows to wait longer when stopping the MySQL server
works for Windows 2000 and XP. It does not work for Windows NT, where Windows
waits only 20 seconds for a service to shut down, and after that kills the
service process. You can increase this default by opening the Registry
Editor `\winnt\system32\regedt32.exe' and editing the value of
WaitToKillServiceTimeout at
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control
in the Registry tree. Specify the new larger value in milliseconds.
For example, the value 120000 tells Windows NT to wait up to 120 seconds.
If you don't want to start mysqld as a service, you can start it
from the command line. For instructions, see section 2.3.11 Starting MySQL from the Windows Command Line.
Please see section 2.3.14 Troubleshooting a MySQL Installation Under Windows if you encounter difficulties during installation.
You can test whether the MySQL server is working by executing any of the following commands:
C:\> C:\mysql\bin\mysqlshow C:\> C:\mysql\bin\mysqlshow -u root mysql C:\> C:\mysql\bin\mysqladmin version status proc C:\> C:\mysql\bin\mysql test
If mysqld is slow to respond to TCP/IP connections from client
programs on Windows 9x/Me, there is probably a problem with your DNS. In
this case, start mysqld with the --skip-name-resolve option
and use only localhost and IP numbers in the Host column of
the MySQL grant tables.
You can force a MySQL client to use a named pipe connection rather than
TCP/IP by specifying the --pipe option or by specifying .
(period) as the host name. Use the --socket option to specify the
name of the pipe. As of MySQL 4.1, you should use the
--protocol=PIPE option.
There are two versions of the MySQL command-line tool:
| Binary | Description |
mysql | Compiled on native Windows, offering limited text editing capabilities. |
mysqlc | Compiled with the Cygnus GNU compiler and
libraries, which offers readline editing. mysqlc was
intended for use primarily with Windows 9x/Me. It does not support the
updated authentication protocol used beginning with MySQL 4.1, and is
not supported in MySQL 4.1 and above. Beginning with MySQL 4.1.8, it is
no longer included in MySQL Windows distributions.
|
If you want to use mysqlc, you must have a copy of the
`cygwinb19.dll' library installed somewhere that mysqlc
can find it. Current distributions of MySQL include this library
in the same directory as mysqlc (the `bin' directory
under the base directory of your MySQL installation). If your
distribution does not have the cygwinb19.dll library in the
`bin' directory, look for it in the lib directory and
copy it to your Windows system directory
(`\Windows\system' or a similar place).
When installing and running MySQL for the first time, you may encounter certain errors that prevent the MySQL server from starting. The purpose of this section is to help you diagnose and correct some of these errors.
Your first resource when troubleshooting server issues is the error log. The MySQL server uses the error log to record information relevant to the error that is preventing the server from starting. The error log is located in the data directory specified in your `my.ini' file. The default data directory location is `C:\mysql\data'. See section 5.9.1 The Error Log.
Another source of information regarding possible errors is the console
messages displayed when the MySQL service is starting. Use the NET
START mysql command from the command line after installing mysqld as
a service to see any error messages regarding the starting of the MySQL
server as a service.
See section 2.3.12 Starting MySQL as a Windows Service.
The following are examples of some of the more common error messages you may encounter when installing MySQL and starting the server for the first time:
System error 1067 has occurred. Fatal error: Can't open privilege tables: Table 'mysql.host' doesn't exist
These messages occur when the MySQL server cannot find the mysql
privileges database or other critical files. This error is often encountered
when the MySQL base or data directories are installed in different
locations than the default locations (`C:\mysql' and
`C:\mysql\data', respectively).
If you have installed MySQL to a directory other than `C:\mysql' you
need to ensure that the MySQL server is aware of this through the use of a
configuration (my.ini) file. The my.ini file needs to be
located in your Windows directory, typically located at `C:\WinNT' or
`C:\WINDOWS'. You can determine its exact location from the value of
the WINDIR environment variable by issuing the following command from
the command prompt:
C:\> echo %WINDIR%
An option file can be created and modified with any text editor,
such as the Notepad program. For example, if MySQL is installed at
`E:\mysql' and the data directory is located at `D:\MySQLdata',
you can create the option file and set up a [mysqld] section to specify
values for the basedir and datadir parameters:
[mysqld] # set basedir to your installation path basedir=E:/mysql # set datadir to the location of your data directory datadir=D:/MySQLdata
Note that Windows pathnames are specified in option files using forward slashes rather than backslashes. If you do use backslashes, you must double them:
[mysqld] # set basedir to your installation path basedir=C:\\Program Files\\mysql # set datadir to the location of your data directory datadir=D:\\MySQLdata
See section 2.3.8 Creating an Option File.
This section lists some of the steps you should take when upgrading MySQL on Windows.
C:\> NET STOP MySQLIf you are not running the MySQL server as a service, use the following command to stop the server:
C:\> C:\mysql\bin\mysqladmin -u root shutdown
WinMySQLAdmin program if it is running.
C:\> C:\mysql\bin\mysqld --removeIf you do not remove the existing service, the MySQL Installation Wizard may fail to properly install the new MySQL service.
C:\mysql4. Overwriting the existing installation is recommended.
NET START MySQL if you run MySQL
as a service, or invoke mysqld directly otherwise.
MySQL for Windows has proven itself to be very stable. The Windows version of MySQL has the same features as the corresponding Unix version, with the following exceptions:
mysqld for an extended time on Windows 95 if your server handles
many connections! Other versions of Windows don't suffer from this bug.
pread() and pwrite() calls to be
able to mix INSERT and SELECT. Currently we use mutexes
to emulate pread()/pwrite(). We will, in the long run,
replace the file level interface with a virtual interface so that we can
use the readfile()/writefile() interface on NT, 2000, and XP to
get more speed.
The current implementation limits the number of open files MySQL can use to
2,048 (1,024 before MySQL 4.0.19), which means that you will not be able to
run as many concurrent threads on NT, 2000, and XP as on Unix.
mysqladmin kill will not work on a sleeping connection.
mysqladmin shutdown can't abort as long as there are sleeping
connections.
ALTER TABLE
ALTER TABLE statement, the table is locked
from being used by other threads. This has to do with the fact that on Windows,
you can't delete a file that is in use by another thread. In the future,
we may find some way to work around this problem.
DROP TABLE
DROP TABLE on a table that is in use by a MERGE table will
not work on Windows because the MERGE handler does the table mapping
hidden from the upper layer of MySQL. Because Windows doesn't allow you
to drop files that are open, you first must flush all MERGE
tables (with FLUSH TABLES) or drop the MERGE table before
dropping the table. We will fix this at the same time we introduce
views.
DATA DIRECTORY and INDEX DIRECTORY
DATA DIRECTORY and INDEX DIRECTORY options for
CREATE TABLE are ignored on Windows, because Windows doesn't support
symbolic links. These options also are ignored on systems that have a
non-functional realpath() call.
DROP DATABASE
mysqladmin shutdown.
LOAD
DATA INFILE or SELECT ... INTO OUTFILE,
use Unix-style filenames with `/' characters:
mysql> LOAD DATA INFILE 'C:/tmp/skr.txt' INTO TABLE skr; mysql> SELECT * INTO OUTFILE 'C:/tmp/skr.txt' FROM skr;Alternatively, you must double the `\' character:
mysql> LOAD DATA INFILE 'C:\\tmp\\skr.txt' INTO TABLE skr; mysql> SELECT * INTO OUTFILE 'C:\\tmp\\skr.txt' FROM skr;
^Z / CHAR(24), Windows will think it
has encountered end-of-file and abort the program.
This is mainly a problem when you try to apply a binary log as follows:
C:\> mysqlbinlog binary-log-name | mysql --user=rootIf you have a problem applying the log and suspect that it is because of a
^Z / CHAR(24) character, you can use the following workaround:
C:\> mysqlbinlog binary-log-file --result-file=/tmp/bin.sql C:\> mysql --user=root --execute "source /tmp/bin.sql"The latter command also can be used to reliably read in any SQL file that may contain binary data.
Access denied for user error
Access denied
for user 'some-user'@'unknown' to database 'mysql', this means
that MySQL cannot resolve your hostname properly.
To fix this, you should create a file named `\windows\hosts' containing
the following information:
127.0.0.1 localhost
Here are some open issues for anyone who might want to help us improve MySQL on Windows:
MYSQL.DLL server. This should include everything in
a standard MySQL server, except thread creation. This will make
MySQL much easier to use in applications that don't need a true
client/server and don't need to access the server from other hosts.
mysqld from the Task Manager
in Windows 95. For the moment, you must use mysqladmin shutdown.
readline to Windows for use in the mysql command-line tool.
mysql,
mysqlshow, mysqladmin, and mysqldump) would be nice.
mysqladmin kill on Windows.
The recommended way to install MySQL on Linux is by using the RPM
packages. The MySQL RPMs are currently built on a SuSE Linux 7.3
system, but should work on most versions of Linux that support rpm
and use glibc.
To obtain RPM packages, see section 2.1.3 How to Get MySQL.
Note: RPM distributions of MySQL often are provided by other vendors. Be aware that they may differ in features and capabilities from those built by MySQL AB, and that the instructions in this manual do not necessarily apply to installing them. The vendor's instructions should be consulted instead.
If you have problems with an RPM file (for example, if you receive the error
``Sorry, the host 'xxxx' could not be looked up''), see
section 2.12.1.2 Linux Binary Distribution Notes.
In most cases, you only need to install the MySQL-server and
MySQL-client packages to get a functional MySQL installation. The
other packages are not required for a standard installation.
If you want to run a MySQL-Max server that has additional capabilities,
you should also install the MySQL-Max RPM. However, you should do so only
after installing the MySQL-server RPM.
See section 5.1.2 The mysqld-max Extended MySQL Server.
If you get a dependency failure when trying to install the MySQL 4.0
packages (for example, ``error: removing these packages would break dependencies:
libmysqlclient.so.10 is needed by ...''), you should also install
the package MySQL-shared-compat, which includes both the
shared libraries for backward compatibility (libmysqlclient.so.12
for MySQL 4.0 and libmysqlclient.so.10 for MySQL 3.23).
Many Linux distributions still ship with MySQL 3.23 and they usually link
applications dynamically to save disk space. If these shared libraries are
in a separate package (for example, MySQL-shared), it is
sufficient to simply leave this package installed and just upgrade
the MySQL server and client packages (which are statically linked
and do not depend on the shared libraries). For distributions that
include the shared libraries in the same package as the MySQL server
(for example, Red Hat Linux), you could either install our 3.23
MySQL-shared RPM, or use the MySQL-shared-compat package instead.
The following RPM packages are available:
MySQL-server-VERSION.i386.rpm
The MySQL server. You will need this unless you only want to
connect to a MySQL server running on another machine. Note:
Server RPM files were called MySQL-VERSION.i386.rpm before
MySQL 4.0.10. That is, they did not have -server in the name.
MySQL-Max-VERSION.i386.rpm
The MySQL-Max server. This server has additional capabilities that the
one provided in the MySQL-server RPM does not. You must install the
MySQL-server RPM first, because the MySQL-Max RPM depends on it.
MySQL-client-VERSION.i386.rpm
The standard MySQL client programs. You probably always want to
install this package.
MySQL-bench-VERSION.i386.rpm
Tests and benchmarks. Requires Perl and the DBD::mysql module.
MySQL-devel-VERSION.i386.rpm
The libraries and include files that are needed if you want to compile other
MySQL clients, such as the Perl modules.
MySQL-shared-VERSION.i386.rpm
This package contains the shared libraries (libmysqlclient.so*)
that certain languages and applications need to dynamically load and
use MySQL.
MySQL-shared-compat-VERSION.i386.rpm
This package includes the shared libraries for both MySQL 3.23 and
MySQL 4.0. Install this package instead of MySQL-shared if you
have applications installed that are dynamically linked against MySQL
3.23 but you want to upgrade to MySQL 4.0 without breaking the library
dependencies. This package has been available since MySQL 4.0.13.
MySQL-embedded-VERSION.i386.rpm
The embedded MySQL server library (from MySQL 4.0).
MySQL-VERSION.src.rpm
This contains the source code for all of the previous packages. It can also
be used to rebuild the RPMs on other architectures (for example, Alpha or SPARC).
To see all files in an RPM package (for example, a MySQL-server
RPM), run:
shell> rpm -qpl MySQL-server-VERSION.i386.rpm
To perform a standard minimal installation, run:
shell> rpm -i MySQL-server-VERSION.i386.rpm shell> rpm -i MySQL-client-VERSION.i386.rpm
To install just the client package, run:
shell> rpm -i MySQL-client-VERSION.i386.rpm
RPM provides a feature to verify the integrity and authenticity of packages
before installing them. If you would like to learn more about this feature,
see section 2.1.4 Verifying Package Integrity Using MD5 Checksums or GnuPG.
The server RPM places data under the `/var/lib/mysql' directory. The
RPM also creates a login account for a user named mysql (if one does not
exist) to use for running the MySQL server, and
creates the appropriate entries in `/etc/init.d/' to start the
server automatically at boot time. (This means that if you have performed a
previous installation and have made changes to its startup script, you may
want to make a copy of the script so that you don't lose it when you install a
newer RPM.) See section 2.9.2.2 Starting and Stopping MySQL Automatically for more information on how MySQL can be
started automatically on system startup.
If you want to install the MySQL RPM on older Linux distributions that do not support initialization scripts in `/etc/init.d' (directly or via a symlink), you should create a symbolic link that points to the location where your initialization scripts actually are installed. For example, if that location is `/etc/rc.d/init.d', use these commands before installing the RPM to create `/etc/init.d' as a symbolic link that points there:
shell> cd /etc shell> ln -s rc.d/init.d .
However, all current major Linux distributions should support the new directory layout that uses `/etc/init.d', because it is required for LSB (Linux Standard Base) compliance.
If the RPM files that you install include MySQL-server, the
mysqld server should be up and running after installation.
You should be able to start using MySQL.
If something goes wrong, you can find more information in the binary installation section. See section 2.7 Installing MySQL on Other Unix-Like Systems.
Note: The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in section 2.9 Post-Installation Setup and Testing.
Beginning with MySQL 4.0.11, you can install MySQL on Mac OS X 10.2.x (``Jaguar'') and up using a Mac OS X binary package in PKG format instead of the binary tarball distribution. Please note that older versions of Mac OS X (for example, 10.1.x) are not supported by this package.
The package is located inside a disk image (.dmg) file that you
first need to mount by double-clicking its icon in the Finder. It should
then mount the image and display its contents.
To obtain MySQL, see section 2.1.3 How to Get MySQL.
Note: Before proceeding with the installation, be sure to
shut down all running MySQL server instances by either
using the MySQL Manager Application (on Mac OS X Server) or via
mysqladmin shutdown on the command line.
To actually install the MySQL PKG file, double-click on the package icon. This launches the Mac OS X Package Installer, which will guide you through the installation of MySQL.
Due to a bug in the Mac OS X package installer, you may see this error message in the destination disk selection dialog:
You cannot install this software on this disk. (null)
If this error occurs, simply click the Go Back button once to return
to the previous screen. Then click Continue to advance to the
destination disk selection again, and you should be able to choose the
destination disk correctly. We have reported this bug to Apple and it is
investigating this problem.
The Mac OS X PKG of MySQL will install itself into
`/usr/local/mysql-VERSION' and will also install a symbolic link,
`/usr/local/mysql', pointing to the new location. If a directory named
`/usr/local/mysql' exists, it will be renamed to
`/usr/local/mysql.bak' first. Additionally, the installer will create the
grant tables in the mysql database by executing mysql_install_db
after the installation.
The installation layout is similar to that of a tar file binary
distribution; all MySQL binaries are located in the directory
`/usr/local/mysql/bin'. The MySQL socket file is created as
`/tmp/mysql.sock' by default.
See section 2.1.5 Installation Layouts.
MySQL installation requires a Mac OS X user account named mysql. A
user account with this name should exist by default on Mac OS X 10.2 and up.
If you are running Mac OS X Server, you have a version of MySQL installed. The versions of MySQL that ship with Mac OS X Server versions are shown in the following table:
| Mac OS X Server Version | MySQL Version |
| 10.2-10.2.2 | 3.23.51 |
| 10.2.3-10.2.6 | 3.23.53 |
| 10.3 | 4.0.14 |
| 10.3.2 | 4.0.16 |
This manual section covers the installation of the official MySQL Mac OS X PKG only. Make sure to read Apple's help information about installing MySQL: Run the ``Help View'' application, select ``Mac OS X Server'' help, do a search for ``MySQL,'' and read the item entitled ``Installing MySQL.''
For pre-installed versions of MySQL on Mac OS X Server, note especially that
you should start mysqld with safe_mysqld instead of
mysqld_safe if MySQL is older than version 4.0.
If you previously used Marc Liyanage's MySQL packages for Mac OS X from http://www.entropy.ch, you can simply follow the update instructions for packages using the binary installation layout as given on his pages.
If you are upgrading from Marc's 3.23.xx versions or from the Mac OS X Server version of MySQL to the official MySQL PKG, you also need to convert the existing MySQL privilege tables to the current format, because some new security privileges have been added. See section 2.10.7 Upgrading the Grant Tables.
If you would like to automatically start up MySQL during system startup, you
also need to install the MySQL Startup Item. Starting with MySQL 4.0.15, it
is part of the Mac OS X installation disk images as a separate installation
package. Simply double-click the MySQLStartupItem.pkg icon and follow
the instructions to install it.
Note that the Startup Item need be installed only once! There is no need to install it each time you upgrade the MySQL package later.
The Startup Item will be installed into
`/Library/StartupItems/MySQLCOM'. (Before MySQL 4.1.2, the location
was `/Library/StartupItems/MySQL', but that collided with the MySQL
Startup Item installed by Mac OS X Server.) Startup Item installation
adds a variable MYSQLCOM=-YES- to the system configuration file
`/etc/hostconfig'. If you would like to disable the automatic startup
of MySQL, simply change this variable to MYSQLCOM=-NO-.
On Mac OS X Server, the default MySQL installation uses the variable
MYSQL in the `/etc/hostconfig' file. The MySQL AB Startup Item
installer disables this variable by setting it to MYSQL=-NO-. This
avoids boot time conflicts with the MYSQLCOM variable used by the
MySQL AB Startup Item. However, it does not shut down a running
MySQL server. You should do that yourself.
After the installation, you can start up MySQL by running the following commands in a terminal window. You must have administrator privileges to perform this task.
If you have installed the Startup Item:
shell> sudo /Library/StartupItems/MySQLCOM/MySQLCOM start (Enter your password, if necessary) (Press Control-D or enter "exit" to exit the shell)
For versions of MySQL older than 4.1.3, substitute
/Library/StartupItems/MySQLCOM/MySQLCOM with
/Library/StartupItems/MySQL/MySQL above.
If you don't use the Startup Item, enter the following command sequence:
shell> cd /usr/local/mysql shell> sudo ./bin/mysqld_safe (Enter your password, if necessary) (Press Control-Z) shell> bg (Press Control-D or enter "exit" to exit the shell)
You should be able to connect to the MySQL server, for example, by running `/usr/local/mysql/bin/mysql'.
Note: The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in section 2.9 Post-Installation Setup and Testing.
You might want to add aliases to your shell's resource file to make it easier
to access commonly used programs such as mysql and mysqladmin
from the command line. The syntax for tcsh is:
alias mysql /usr/local/mysql/bin/mysql alias mysqladmin /usr/local/mysql/bin/mysqladmin
For bash, use:
alias mysql=/usr/local/mysql/bin/mysql alias mysqladmin=/usr/local/mysql/bin/mysqladmin
Even better,
add /usr/local/mysql/bin to
your PATH environment variable. For example, add the following
line to your `$HOME/.tcshrc' file if your shell is tcsh:
setenv PATH ${PATH}:/usr/local/mysql/bin
If no `.tcshrc' file exists in your home directory, create it with a text editor.
If you are upgrading an existing installation, please note that installing a new MySQL PKG does not remove the directory of an older installation. Unfortunately, the Mac OS X Installer does not yet offer the functionality required to properly upgrade previously installed packages.
To use your existing databases with the new installation, you'll need to copy the contents of the old data directory to the new data directory. Make sure that neither the old server nor the new one is running when you do this. After you have copied over the MySQL database files from the previous installation and have successfully started the new server, you should consider removing the old installation files to save disk space. Additionally, you should also remove older versions of the Package Receipt directories located in `/Library/Receipts/mysql-VERSION.pkg'.
Porting MySQL to NetWare was an effort spearheaded by Novell. Novell customers will be pleased to note that NetWare 6.5 ships with bundled MySQL binaries, complete with an automatic commercial use license for all servers running that version of NetWare.
MySQL for NetWare is compiled using a combination of Metrowerks
CodeWarrior for NetWare and special cross-compilation versions of the
GNU autotools.
The latest binary packages for NetWare can be obtained at http://dev.mysql.com/downloads/. See section 2.1.3 How to Get MySQL.
In order to host MySQL, the NetWare server must meet these requirements:
To install MySQL for NetWare, use the following procedure:
SERVER: mysqladmin -u root shutdown
SERVER: SEARCH ADD SYS:MYSQL\BIN
mysql_install_db at the server console.
mysqld_safe at the server console.
autoexec.ncf. For example, if your MySQL installation is in
`SYS:MYSQL' and you want MySQL to start automatically, you could
add these lines:
#Starts the MySQL 4.0.x database server SEARCH ADD SYS:MYSQL\BIN MYSQLD_SAFEIf you are running MySQL on NetWare 6.0, we strongly suggest that you use the
--skip-external-locking option on the command line:
#Starts the MySQL 4.0.x database server SEARCH ADD SYS:MYSQL\BIN MYSQLD_SAFE --skip-external-lockingIt will also be necessary to use
CHECK TABLE and REPAIR
TABLE instead of myisamchk, because myisamchk makes use
of external locking. External locking is known to have problems on
NetWare 6.0; the problem has been eliminated in NetWare 6.5.
mysqld_safe on NetWare provides a screen presence. When you unload
(shut down) the mysqld_safe NLM, the screen does not by default go
away. Instead, it prompts for user input:
*<NLM has terminated; Press any key to close the screen>*If you want NetWare to close the screen automatically instead, use the
--autoclose option to mysqld_safe. For example:
#Starts the MySQL 4.0.x database server SEARCH ADD SYS:MYSQL\BIN MYSQLD_SAFE --autoclose
The behavior of mysqld_safe on NetWare is described further in
section 5.1.3 The mysqld_safe Server Startup Script.
If there was an existing installation of MySQL on the server, be sure
to check for existing MySQL startup commands in autoexec.ncf,
and edit or delete them as necessary.
Note: The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in section 2.9 Post-Installation Setup and Testing.
This section covers the installation of MySQL binary distributions that are
provided for various platforms in the form of compressed tar files
(files with a .tar.gz extension). See section 2.1.2.5 MySQL Binaries Compiled by MySQL AB for a
detailed list.
To obtain MySQL, see section 2.1.3 How to Get MySQL.
MySQL tar file binary distributions have names of the form
`mysql-VERSION-OS.tar.gz', where VERSION is a number (for
example, 4.0.17), and OS indicates the type of operating
system for which the distribution is intended (for example,
pc-linux-i686).
In addition to these generic packages, we also offer binaries in platform-specific package formats for selected platforms. See section 2.2 Standard MySQL Installation Using a Binary Distribution for more information on how to install these.
You need the following tools to install a MySQL tar file binary
distribution:
gunzip to uncompress the distribution.
tar to unpack the distribution. GNU tar is known
to work. Some operating systems come with a pre-installed version of
tar that is known to have problems. For example, Mac OS X tar
and Sun tar are known to have problems with long filenames. On Mac
OS X, you can use the pre-installed gnutar program. On other systems
with a deficient tar, you should install GNU tar first.
If you run into problems, please always use mysqlbug when
posting questions to a MySQL mailing list. Even if the problem
isn't a bug, mysqlbug gathers system information that will help others
solve your problem. By not using mysqlbug, you lessen the likelihood
of getting a solution to your problem. You will find mysqlbug in the
`bin' directory after you unpack the distribution. See section 1.4.1.3 How to Report Bugs or Problems.
The basic commands you must execute to install and use a MySQL binary distribution are:
shell> groupadd mysql shell> useradd -g mysql mysql shell> cd /usr/local shell> gunzip < /path/to/mysql-VERSION-OS.tar.gz | tar xvf - shell> ln -s full-path-to-mysql-VERSION-OS mysql shell> cd mysql shell> scripts/mysql_install_db --user=mysql shell> chown -R root . shell> chown -R mysql data shell> chgrp -R mysql . shell> bin/mysqld_safe --user=mysql &
For versions of MySQL older than 4.0, substitute bin/safe_mysqld
for bin/mysqld_safe in the final command.
Note: This procedure does not set up any passwords for MySQL accounts. After following the procedure, proceed to section 2.9 Post-Installation Setup and Testing.
A more detailed version of the preceding description for installing a binary distribution follows:
mysqld to run as:
shell> groupadd mysql shell> useradd -g mysql mysqlThese commands add the
mysql group and the mysql user. The
syntax for useradd and groupadd may differ slightly on different
versions of Unix. They may also be called adduser and addgroup.
You might want to call the user and group something else instead
of mysql. If so, substitute the appropriate name in the
following steps.
root.)
shell> cd /usr/local
shell> gunzip < /path/to/mysql-VERSION-OS.tar.gz | tar xvf - shell> ln -s full-path-to-mysql-VERSION-OS mysqlThe
tar command creates a directory named
`mysql-VERSION-OS'. The
ln command makes a symbolic link to that directory. This lets you refer
more easily to the installation directory as `/usr/local/mysql'.
With GNU tar, no separate invocation of gunzip is necessary.
You can replace the first line with the following
alternative command to uncompress and extract the distribution:
shell> tar zxvf /path/to/mysql-VERSION-OS.tar.gz
shell> cd mysqlYou will find several files and subdirectories in the
mysql directory.
The most important for installation purposes are the `bin' and
`scripts' subdirectories.
PATH environment variable so that your shell finds the MySQL
programs properly. See section F Environment Variables.
mysql_install_db script used to initialize
the mysql database containing the grant tables that store the server
access permissions.
shell> scripts/mysql_install_db --user=mysqlIf you run the command as
root, you should use the --user
option as shown. The value of the option should be the name of the login
account that you created in the first step to use for running the server.
If you run the command while logged in as that user, you can omit the
--user option.
Note that for MySQL versions older than 3.22.10,
mysql_install_db left the server running after creating the grant
tables. This is no longer true; you will need to restart the server after
performing the remaining steps in this procedure.
root and ownership of the
data directory to the user that you will run mysqld as. Assuming
that you are located in the installation directory
(`/usr/local/mysql'), the commands look like this:
shell> chown -R root . shell> chown -R mysql data shell> chgrp -R mysql .The first command changes the owner attribute of the files to the
root user. The second changes the owner attribute of the
data directory to the mysql user. The third changes the
group attribute to the mysql group.
support-files/mysql.server to the location where
your system has its startup files. More information can be found in the
support-files/mysql.server script itself and in
section 2.9.2.2 Starting and Stopping MySQL Automatically.
bin/mysql_setpermission script if
you install the DBI and DBD::mysql Perl modules.
For instructions, see section 2.13 Perl Installation Notes.
mysqlaccess and have the MySQL
distribution in some non-standard place, you must change the location where
mysqlaccess expects to find the mysql client. Edit the
`bin/mysqlaccess' script at approximately line 18. Search for a line
that looks like this:
$MYSQL = '/usr/local/bin/mysql'; # path to mysql executableChange the path to reflect the location where
mysql actually is
stored on your system. If you do not do this, you will get a Broken
pipe error when you run mysqlaccess.
After everything has been unpacked and installed, you should test your distribution.
You can start the MySQL server with the following command:
shell> bin/mysqld_safe --user=mysql &
For versions of MySQL older than 4.0, substitute bin/safe_mysqld
for bin/mysqld_safe in the command.
More information about mysqld_safe is given in
section 5.1.3 The mysqld_safe Server Startup Script.
Note: The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in section 2.9 Post-Installation Setup and Testing.
Before you proceed with the source installation, check first to see whether our binary is available for your platform and whether it will work for you. We put a lot of effort into making sure that our binaries are built with the best possible options.
To obtain a source distribution for MySQL, section 2.1.3 How to Get MySQL.
MySQL source distributions are provided as compressed tar
archives and have names of the form `mysql-VERSION.tar.gz', where
VERSION is a number like 4.1.10a.
You need the following tools to build and install MySQL from source:
gunzip to uncompress the distribution.
tar to unpack the distribution. GNU tar is known
to work. Some operating systems come with a pre-installed version of
tar that is known to have problems. For example, Mac OS X tar
and Sun tar are known to have problems with long filenames. On Mac
OS X, you can use the pre-installed gnutar program. On other systems
with a deficient tar, you should install GNU tar first.
gcc 2.95.2 or later, egcs 1.0.2
or later or egcs 2.91.66, SGI C++, and SunPro C++ are some of the
compilers that are known to work. libg++ is not needed when
using gcc. gcc 2.7.x has a bug that makes it impossible
to compile some perfectly legal C++ files, such as
`sql/sql_base.cc'. If you have only gcc 2.7.x, you must
upgrade your gcc to be able to compile MySQL. gcc
2.8.1 is also known to have problems on some platforms, so it should be
avoided if a new compiler exists for the platform.
gcc 2.95.2 or later is recommended when compiling MySQL
3.23.x.
make program. GNU make is always recommended and is
sometimes required. If you have problems, we recommend trying GNU
make 3.75 or newer.
If you are using a version of gcc recent enough to understand the
-fno-exceptions option, it is very important that you use
this option. Otherwise, you may compile a binary that crashes randomly. We also
recommend that you use -felide-constructors and -fno-rtti along
with -fno-exceptions. When in doubt, do the following:
CFLAGS="-O3" CXX=gcc CXXFLAGS="-O3 -felide-constructors \
-fno-exceptions -fno-rtti" ./configure \
--prefix=/usr/local/mysql --enable-assembler \
--with-mysqld-ldflags=-all-static
On most systems, this will give you a fast and stable binary.
If you run into problems, please always use mysqlbug when
posting questions to a MySQL mailing list. Even if the problem
isn't a bug, mysqlbug gathers system information that will help others
solve your problem. By not using mysqlbug, you lessen the likelihood
of getting a solution to your problem. You will find mysqlbug in the
`scripts' directory after you unpack the distribution.
See section 1.4.1.3 How to Report Bugs or Problems.
The basic commands you must execute to install a MySQL source distribution are:
shell> groupadd mysql shell> useradd -g mysql mysql shell> gunzip < mysql-VERSION.tar.gz | tar -xvf - shell> cd mysql-VERSION shell> ./configure --prefix=/usr/local/mysql shell> make shell> make install shell> cp support-files/my-medium.cnf /etc/my.cnf shell> cd /usr/local/mysql shell> bin/mysql_install_db --user=mysql shell> chown -R root . shell> chown -R mysql var shell> chgrp -R mysql . shell> bin/mysqld_safe --user=mysql &
For versions of MySQL older than 4.0, substitute bin/safe_mysqld
for bin/mysqld_safe in the final command.
If you start from a source RPM, do the following:
shell> rpmbuild --rebuild --clean MySQL-VERSION.src.rpm
This will make a binary RPM that you can install. For older versions of RPM,
you may have to replace the command rpmbuild with rpm instead.
Note: This procedure does not set up any passwords for MySQL accounts. After following the procedure, proceed to section 2.9 Post-Installation Setup and Testing, for post-installation setup and testing.
A more detailed version of the preceding description for installing MySQL from a source distribution follows:
mysqld to run as:
shell> groupadd mysql shell> useradd -g mysql mysqlThese commands add the
mysql group and the mysql user. The
syntax for useradd and groupadd may differ slightly on different
versions of Unix. They may also be called adduser and addgroup.
You might want to call the user and group something else instead
of mysql. If so, substitute the appropriate name in the
following steps.
shell> gunzip < /path/to/mysql-VERSION.tar.gz | tar xvf -This command creates a directory named `mysql-VERSION'. With GNU
tar, no separate invocation of gunzip is necessary.
You can use the following alternative command to uncompress and extract
the distribution:
shell> tar zxvf /path/to/mysql-VERSION-OS.tar.gz
shell> cd mysql-VERSIONNote that currently you must configure and build MySQL from this top-level directory. You cannot build it in a different directory.
shell> ./configure --prefix=/usr/local/mysql shell> makeWhen you run
configure, you might want to specify some options.
Run ./configure --help for a list of options.
section 2.8.2 Typical configure Options, discusses some of the
more useful options.
If configure fails and you are going to send mail to a MySQL mailing
list to ask for assistance, please include any
lines from `config.log' that you think can help solve the problem. Also
include the last couple of lines of output from configure.
Post the bug report using the mysqlbug
script. See section 1.4.1.3 How to Report Bugs or Problems.
If the compile fails, see section 2.8.4 Dealing with Problems Compiling MySQL for help.
shell> make installIf you want to set up an option file, use one of those present in the `support-files' directory as a template. For example:
shell> cp support-files/my-medium.cnf /etc/my.cnfYou might need to run these commands as
root.
If you want to configure support for InnoDB tables, you should edit the
/etc/my.cnf file, remove the # character before the
option lines that start with innodb_..., and modify the option values
to be what you want.
See section 4.3.2 Using Option Files
and section 15.4 InnoDB Configuration.
shell> cd /usr/local/mysql
shell> bin/mysql_install_db --user=mysqlIf you run the command as
root, you should use the --user
option as shown. The value of the option should be the name of the login
account that you created in the first step to use for running the server.
If you run the command while logged in as that user, you can omit the
--user option.
Note that for MySQL versions older than 3.22.10,
mysql_install_db left the server running after creating the grant
tables. This is no longer true; you will need to restart the server after
performing the remaining steps in this procedure.
root and ownership of the
data directory to the user that you will run mysqld as. Assuming
that you are located in the installation directory
(`/usr/local/mysql'), the commands look like this:
shell> chown -R root . shell> chown -R mysql var shell> chgrp -R mysql .The first command changes the owner attribute of the files to the
root user. The second changes the owner attribute of the
data directory to the mysql user. The third changes the
group attribute to the mysql group.
support-files/mysql.server to the location where
your system has its startup files. More information can be found in the
support-files/mysql.server script itself and in
section 2.9.2.2 Starting and Stopping MySQL Automatically.
bin/mysql_setpermission script if
you install the DBI and DBD::mysql Perl modules.
For instructions, see section 2.13 Perl Installation Notes.
After everything has been installed, you should initialize and test your distribution using this command:
shell> /usr/local/mysql/bin/mysqld_safe --user=mysql &
For versions of MySQL older than 4.0, substitute safe_mysqld
for mysqld_safe in the command.
If that command fails immediately and prints mysqld ended, you can
find some information in the `host_name.err' file in the data directory.
More information about mysqld_safe is given in
section 5.1.3 The mysqld_safe Server Startup Script.
Note: The accounts that are listed in the MySQL grant tables initially have no passwords. After starting the server, you should set up passwords for them using the instructions in section 2.9 Post-Installation Setup and Testing.
configure Options
The configure script gives you a great deal of control over how
you configure a MySQL source distribution. Typically you do this
using options on the configure command line. You can also affect
configure using certain environment variables. See section F Environment Variables. For a list of options supported by configure, run
this command:
shell> ./configure --help
Some of the more commonly used configure options are described here:
--without-server option:
shell> ./configure --without-serverIf you don't have a C++ compiler,
mysql will not compile (it is the
one client program that requires C++). In this case,
you can remove the code in configure that tests for the C++ compiler
and then run ./configure with the --without-server option. The
compile step will still try to build mysql, but you can ignore any
warnings about `mysql.cc'. (If make stops, try make -k
to tell it to continue with the rest of the build even if errors occur.)
libmysqld.a) you should
use the --with-embedded-server option.
configure command something like one
of these:
shell> ./configure --prefix=/usr/local/mysql
shell> ./configure --prefix=/usr/local \
--localstatedir=/usr/local/mysql/data
The first command changes the installation prefix so that everything is
installed under `/usr/local/mysql' rather than the default of
`/usr/local'. The second command preserves the default installation
prefix, but overrides the default location for database directories
(normally `/usr/local/var') and changes it to
/usr/local/mysql/data. After you have compiled MySQL, you can
change these options with option files. See section 4.3.2 Using Option Files.
configure command like this:
shell> ./configure \
--with-unix-socket-path=/usr/local/mysql/tmp/mysql.sock
The socket filename must be an absolute pathname.
You can also change the location of `mysql.sock' later by using a MySQL
option file. See section A.4.5 How to Protect or Change the MySQL Socket File `/tmp/mysql.sock'.
configure like this:
shell> ./configure --with-client-ldflags=-all-static \
--with-mysqld-ldflags=-all-static
gcc and don't have libg++ or libstdc++
installed, you can tell configure to use gcc as your C++
compiler:
shell> CC=gcc CXX=gcc ./configureWhen you use
gcc as your C++ compiler, it will not attempt to link in
libg++ or libstdc++. This may be a good idea to do even if you
have these libraries installed, because some versions of them have
caused strange problems for MySQL users in the past.
The following list indicates some compilers and environment variable settings
that are commonly used with each one.
gcc 2.7.2:
CC=gcc CXX=gcc CXXFLAGS="-O3 -felide-constructors"
egcs 1.0.3a:
CC=gcc CXX=gcc CXXFLAGS="-O3 -felide-constructors \ -fno-exceptions -fno-rtti"
gcc 2.95.2:
CFLAGS="-O3 -mpentiumpro" CXX=gcc CXXFLAGS="-O3 -mpentiumpro \ -felide-constructors -fno-exceptions -fno-rtti"
pgcc 2.90.29 or newer:
CFLAGS="-O3 -mpentiumpro -mstack-align-double" CXX=gcc \ CXXFLAGS="-O3 -mpentiumpro -mstack-align-double \ -felide-constructors -fno-exceptions -fno-rtti"
configure line:
--prefix=/usr/local/mysql --enable-assembler \ --with-mysqld-ldflags=-all-staticThe full
configure line would, in other words, be something like the
following for all recent gcc versions:
CFLAGS="-O3 -mpentiumpro" CXX=gcc CXXFLAGS="-O3 -mpentiumpro \ -felide-constructors -fno-exceptions -fno-rtti" ./configure \ --prefix=/usr/local/mysql --enable-assembler \ --with-mysqld-ldflags=-all-staticThe binaries we provide on the MySQL Web site at http://www.mysql.com/ are all compiled with full optimization and should be perfect for most users. See section 2.1.2.5 MySQL Binaries Compiled by MySQL AB. There are some configuration settings you can tweak to make an even faster binary, but these are only for advanced users. See section 7.5.4 How Compiling and Linking Affects the Speed of MySQL. If the build fails and produces errors about your compiler or linker not being able to create the shared library `libmysqlclient.so.#' (where `#' is a version number), you can work around this problem by giving the
--disable-shared option to configure. In this case,
configure will not build a shared `libmysqlclient.so.#' library.
latin1 (ISO-8859-1) character set. To
change the default set, use the --with-charset option:
shell> ./configure --with-charset=CHARSETCHARSET may be one of
big5, cp1251, cp1257,
czech, danish, dec8, dos, euc_kr,
gb2312, gbk, german1, hebrew, hp8,
hungarian, koi8_ru, koi8_ukr, latin1,
latin2, sjis, swe7, tis620, ujis,
usa7, or win1251ukr.
See section 5.8.1 The Character Set Used for Data and Sorting.
As of MySQL 4.1.1, the default collation may also be specified. MySQL uses
the latin1_swedish_ci collation. To change this, use the
--with-collation option:
shell> ./configure --with-collation=COLLATIONTo change both the character set and the collation, use both the
--with-charset and --with-collation options.
The collation must be a legal collation for the character set.
(Use the SHOW COLLATION statement to determine which collations are
available for each character set.)
If you want to convert characters between the server and the client,
you should take a look at the SET CHARACTER SET statement.
See section 13.5.3 SET Syntax.
Warning: If you change character sets after having created any
tables, you will have to run myisamchk -r -q --set-character-set=charset
on every table. Your
indexes may be sorted incorrectly otherwise. (This can happen if you
install MySQL, create some tables, then reconfigure
MySQL to use a different character set and reinstall it.)
With the configure option --with-extra-charsets=LIST, you can
define which additional character sets should be compiled into the server.
LIST is either a list of character set names separated by spaces,
complex to include all character sets that can't be dynamically loaded,
or all to include all character sets into the binaries.
--with-debug
option:
shell> ./configure --with-debugThis causes a safe memory allocator to be included that can find some errors and that provides output about what is happening. See section E.1 Debugging a MySQL Server.
--enable-thread-safe-client configure option. This will create a
libmysqlclient_r library with which you should link your threaded
applications. See section 22.2.15 How to Make a Threaded Client.
Caution: You should read this section only if you are interested in helping us test our new code. If you just want to get MySQL up and running on your system, you should use a standard release distribution (either a binary or source distribution will do).
To obtain our most recent development source tree, use these instructions:
shell> bk clone bk://mysql.bkbits.net/mysql-3.23 mysql-3.23To clone the 4.0 stable (production) branch, use this command:
shell> bk clone bk://mysql.bkbits.net/mysql-4.0 mysql-4.0To clone the 4.1 stable (production) branch, use this command:
shell> bk clone bk://mysql.bkbits.net/mysql-4.1 mysql-4.1To clone the 5.0 development branch, use this command:
shell> bk clone bk://mysql.bkbits.net/mysql-5.0 mysql-5.0In the preceding examples, the source tree will be set up in the `mysql-3.23/', `mysql-4.0/', `mysql-4.1/', or `mysql-5.0/' subdirectory of your current directory. If you are behind a firewall and can only initiate HTTP connections, you can also use BitKeeper via HTTP. If you are required to use a proxy server, set the environment variable
http_proxy to point to your proxy:
shell> export http_proxy="http://your.proxy.server:8080/"Replace the
bk:// with http:// when doing
a clone. Example:
shell> bk clone http://mysql.bkbits.net/mysql-4.1 mysql-4.1The initial download of the source tree may take a while, depending on the speed of your connection. Please be patient.
make, autoconf 2.58 (or newer),
automake 1.8, libtool 1.5, and m4 to run the next
set of commands. Even though many operating systems come with their
own implementation of make, chances are high that the compilation
will fail with strange error messages. Therefore, it is highly recommended
that you use GNU make (sometimes named gmake) instead.
Fortunately, a large number of operating systems ship with the GNU
toolchain preinstalled or supply installable packages of these. In any case,
they can also be downloaded from the following locations:
bison 1.75 or later. Older versions of bison may report this
error:
sql_yacc.yy:#####: fatal error: maximum table size (32767) exceededNote: The maximum table size is not actually exceeded; the error is caused by bugs in older versions of
bison.
Versions of MySQL before version 4.1 may also compile with other
yacc implementations (for example, BSD yacc 91.7.30). For later
versions, GNU bison is required.
The following example shows the typical commands required to configure a
source tree. The first cd command changes location into the top-level
directory of the tree; replace `mysql-4.0' with the appropriate directory
name.
shell> cd mysql-4.0 shell> bk -r edit shell> aclocal; autoheader; autoconf; automake shell> (cd innobase; aclocal; autoheader; autoconf; automake) shell> (cd bdb/dist; sh s_all) shell> ./configure # Add your favorite options here makeThe command lines that change directory into the `innobase' and `bdb/dist' directories are used to configure the
InnoDB and
Berkeley DB (BDB) storage engines. You can omit these command lines if
you to not require InnoDB or BDB support.
If you get some strange errors during this stage, verify that you really
have libtool installed.
A collection of our standard configuration scripts is located in the
`BUILD/' subdirectory. You may find it more convenient to use the
`BUILD/compile-pentium-debug' script than the preceding set of
shell commands. To compile on a different architecture,
modify the script by removing flags that are Pentium-specific.
make install. Be careful with this
on a production machine; the command may overwrite your live release
installation. If you have another installation of MySQL, we
recommend that you run ./configure with different values for the
--prefix, --with-tcp-port, and --unix-socket-path options
than those used for your production server.
make test. See section 25.1.2 MySQL Test Suite.
make stage and the distribution does
not compile, please report it in our bugs database at
http://bugs.mysql.com/. If you
have installed the latest versions of the required GNU tools, and they
crash trying to process our configuration files, please report that also.
However, if you execute aclocal and get a command not found
error or a similar problem, do not report it. Instead, make sure that all
the necessary tools are installed and that your PATH variable is
set correctly so that your shell can find them.
bk clone operation to obtain the source tree, you
should run bk pull periodically to get updates.
bk revtool. If you see some funny diffs or code that you have a
question about, do not hesitate to send email to the MySQL internals
mailing list.
See section 1.4.1.1 The MySQL Mailing Lists.
Also, if you think you have a better idea
on how to do something, send an email message to the same address with a patch.
bk diffs will produce a patch for you after you have made changes
to the source. If you do not have the time to code your idea, just send
a description.
bk helptool.
bk ci or bk citool) will
trigger the posting of a message with the changeset to our internals
mailing list, as well as the usual openlogging.org submission with
just the changeset comments.
Generally, you wouldn't need to use commit (since the public tree will
not allow bk push), but rather use the bk diffs method
described previously.
You can also browse changesets, comments, and source code online. For example, to browse this information for MySQL 4.1, go to http://mysql.bkbits.net:8080/mysql-4.1.
The manual is in a separate tree that can be cloned with:
shell> bk clone bk://mysql.bkbits.net/mysqldoc mysqldoc
There are also public BitKeeper trees for MySQL Control Center and MyODBC. They can be cloned respectively as follows.
To clone MySQL Control center, use this command:
shell> bk clone http://mysql.bkbits.net/mysqlcc mysqlcc
To clone MyODBC, use this command:
shell> bk clone http://mysql.bkbits.net/myodbc3 myodbc3
To clone Connector/NET, use this command:
shell> bk clone http://mysql.bkbits.net/connector-net connector-net
All MySQL programs compile cleanly for us with no warnings on
Solaris or Linux using gcc. On other systems, warnings may occur due to
differences in system include files. See section 2.8.5 MIT-pthreads Notes for warnings
that may occur when using MIT-pthreads. For other problems, check
the following list.
The solution to many problems involves reconfiguring. If you do need to reconfigure, take note of the following:
configure is run after it has previously been run, it may use
information that was gathered during its previous invocation. This
information is stored in `config.cache'. When configure starts
up, it looks for that file and reads its contents if it exists, on the
assumption that the information is still correct. That assumption is invalid
when you reconfigure.
configure, you must run make again
to recompile. However, you may want to remove old object files from previous
builds first because they were compiled using different configuration options.
To prevent old configuration information or object files from being used,
run these commands before re-running configure:
shell> rm config.cache shell> make clean
Alternatively, you can run make distclean.
The following list describes some of the problems when compiling MySQL that have been found to occur most often:
Internal compiler error: program cc1plus got fatal signal 11 Out of virtual memory Virtual memory exhaustedThe problem is that
gcc requires a huge amount of memory to compile
`sql_yacc.cc' with inline functions. Try running configure with
the --with-low-memory option:
shell> ./configure --with-low-memoryThis option causes
-fno-inline to be added to the compile line if you
are using gcc and -O0 if you are using something else. You
should try the --with-low-memory option even if you have so much
memory and swap space that you think you can't possibly have run out. This
problem has been observed to occur even on systems with generous hardware
configurations and the --with-low-memory option usually fixes it.
configure picks c++ as the compiler name and
GNU c++ links with -lg++. If you are using gcc,
that behavior can cause problems during configuration such as this:
configure: error: installation or configuration problem: C++ compiler cannot create executables.You might also observe problems during compilation related to
g++, libg++, or libstdc++.
One cause of these problems is that you may not have g++, or you may
have g++ but not libg++, or libstdc++. Take a look at
the `config.log' file. It should contain the exact reason why your C++
compiler didn't work. To work around these problems, you can use gcc
as your C++ compiler. Try setting the environment variable CXX to
"gcc -O3". For example:
shell> CXX="gcc -O3" ./configureThis works because
gcc compiles C++ sources as well as g++
does, but does not link in libg++ or libstdc++ by default.
Another way to fix these problems is to install g++,
libg++, and libstdc++. We would, however, like to recommend
that you not use libg++ or libstdc++ with MySQL because this will
only increase the binary size of mysqld without giving you any benefits.
Some versions of these libraries have also caused strange problems for
MySQL users in the past.
Using gcc as the C++ compiler is also required if you want to
compile MySQL with RAID functionality (see section 13.2.6 CREATE TABLE Syntax for more info
on RAID table type) and you are using GNU gcc version 3 and above. If
you get errors like those following during the linking stage when you
configure MySQL to compile with the option --with-raid, try to use
gcc as your C++ compiler by defining the CXX environment
variable:
gcc -O3 -DDBUG_OFF -rdynamic -o isamchk isamchk.o sort.o libnisam.a ../mysys/libmysys.a ../dbug/libdbug.a ../strings/libmystrings.a -lpthread -lz -lcrypt -lnsl -lm -lpthread ../mysys/libmysys.a(raid.o)(.text+0x79): In function `my_raid_create':: undefined reference to `operator new(unsigned)' ../mysys/libmysys.a(raid.o)(.text+0xdd): In function `my_raid_create':: undefined reference to `operator delete(void*)' ../mysys/libmysys.a(raid.o)(.text+0x129): In function `my_raid_open':: undefined reference to `operator new(unsigned)' ../mysys/libmysys.a(raid.o)(.text+0x189): In function `my_raid_open':: undefined reference to `operator delete(void*)' ../mysys/libmysys.a(raid.o)(.text+0x64b): In function `my_raid_close':: undefined reference to `operator delete(void*)' collect2: ld returned 1 exit status
make to GNU make:
making all in mit-pthreads make: Fatal error in reader: Makefile, line 18: Badly formed macro assignmentOr:
make: file `Makefile' line 18: Must be a separator (:Or:
pthread.h: No such file or directorySolaris and FreeBSD are known to have troublesome
make programs.
GNU make Version 3.75 is known to work.
CFLAGS and CXXFLAGS environment
variables. You can also specify the compiler names this way using CC
and CXX. For example:
shell> CC=gcc shell> CFLAGS=-O3 shell> CXX=gcc shell> CXXFLAGS=-O3 shell> export CC CFLAGS CXX CXXFLAGSSee section 2.1.2.5 MySQL Binaries Compiled by MySQL AB, for a list of flag definitions that have been found to be useful on various systems.
gcc compiler:
client/libmysql.c:273: parse error before `__attribute__'
gcc 2.8.1 is known to work, but we recommend using gcc 2.95.2 or
egcs 1.0.3a instead.
mysqld,
configure didn't correctly detect the type of the last argument to
accept(), getsockname(), or getpeername():
cxx: Error: mysqld.cc, line 645: In this statement, the referenced
type of the pointer value ''length'' is ''unsigned long'',
which is not compatible with ''int''.
new_sock = accept(sock, (struct sockaddr *)&cAddr, &length);
To fix this, edit the `config.h' file (which is generated by
configure). Look for these lines:
/* Define as the base type of the last arg to accept */ #define SOCKET_SIZE_TYPE XXXChange
XXX to size_t or int, depending on your
operating system. (Note that you will have to do this each time you run
configure because configure regenerates `config.h'.)
"sql_yacc.yy", line xxx fatal: default action causes potential...This is a sign that your version of
yacc is deficient.
You probably need to install bison (the GNU version of yacc)
and use that instead.
gawk instead of the default
mawk if you want to compile MySQL 4.1 or higher with Berkeley DB
support.
mysqld or a MySQL client, run
configure with the --with-debug option, then recompile and
link your clients with the new client library. See section E.2 Debugging a MySQL Client.
libmysql.c:1329: warning: passing arg 5 of `gethostbyname_r' from incompatible pointer type libmysql.c:1329: too few arguments to function `gethostbyname_r' libmysql.c:1329: warning: assignment makes pointer from integer without a cast make[2]: *** [libmysql.lo] Error 1By default, the
configure script attempts to determine the correct
number of arguments by using g++ the GNU C++ compiler. This test
yields wrong results if g++ is not installed. There are two ways
to work around this problem:
g++ is installed. On some Linux
distributions, the required package is called gpp; on others, it
is named gcc-c++.
gcc as your C++ compiler by setting the CXX environment
variable to gcc:
export CXX="gcc"
configure again afterward.
This section describes some of the issues involved in using MIT-pthreads.
On Linux, you should not use MIT-pthreads. Use the installed LinuxThreads implementation instead. See section 2.12.1 Linux Notes.
If your system does not provide native thread support, you will need to build MySQL using the MIT-pthreads package. This includes older FreeBSD systems, SunOS 4.x, Solaris 2.4 and earlier, and some others. See section 2.1.1 Operating Systems Supported by MySQL.
Beginning with MySQL 4.0.2, MIT-pthreads is no longer part of the source distribution. If you require this package, you need to download it separately from http://www.mysql.com/Downloads/Contrib/pthreads-1_60_beta6-mysql.tar.gz
After downloading, extract this source archive into the top level of the
MySQL source directory. It will create a new subdirectory named
mit-pthreads.
configure with the --with-mit-threads option:
shell> ./configure --with-mit-threadsBuilding in a non-source directory is not supported when using MIT-pthreads because we want to minimize our changes to this code.
--without-server
to build only the client code, clients will not know whether
MIT-pthreads is being used and will use Unix socket connections by default.
Because Unix socket files do not work under MIT-pthreads on some platforms, this
means you will need to use -h or --host when you run client
programs.
--external-locking option. This is needed
only if you want to be able to run two MySQL servers against the same data
files, which is not recommended.
bind() command fails to bind to a socket without
any error message (at least on Solaris). The result is that all connections
to the server fail. For example:
shell> mysqladmin version mysqladmin: connect to server at '' failed; error: 'Can't connect to mysql server on localhost (146)'The solution to this is to kill the
mysqld server and restart it.
This has only happened to us when we have forced down the server and done
a restart immediately.
sleep() system call isn't interruptible with
SIGINT (break). This is only noticeable when you run
mysqladmin --sleep. You must wait for the sleep() call to
terminate before the interrupt is served and the process stops.
ld: warning: symbol `_iob' has differing sizes:
(file /my/local/pthreads/lib/libpthread.a(findfp.o) value=0x4;
file /usr/lib/libc.so value=0x140);
/my/local/pthreads/lib/libpthread.a(findfp.o) definition taken
ld: warning: symbol `__iob' has differing sizes:
(file /my/local/pthreads/lib/libpthread.a(findfp.o) value=0x4;
file /usr/lib/libc.so value=0x140);
/my/local/pthreads/lib/libpthread.a(findfp.o) definition taken
implicit declaration of function `int strtoll(...)' implicit declaration of function `int strtoul(...)'
readline to work with MIT-pthreads. (This isn't
needed, but may be interesting for someone.)
These instructions describe how to build MySQL binaries from source for versions 4.1 and above on Windows. Instructions are provided for building binaries from a standard source distribution or from the BitKeeper tree that contains the latest development source.
Note: The instructions in this document are strictly for users who want to test MySQL on Windows from the latest source distribution or from the BitKeeper tree. For production use, MySQL AB does not advise using a MySQL server built by yourself from source. Normally, it is best to use precompiled binary distributions of MySQL that are built specifically for optimal performance on Windows by MySQL AB. Instructions for installing a binary distributions are available at section 2.3 Installing MySQL on Windows.
To build MySQL on Windows from source, you need the following compiler and resources available on your Windows system:
You'll also need a MySQL source distribution for Windows. There are two ways you can get a source distribution for MySQL version 4.1 and above:
If you are using a Windows source distribution, you can go directly to section 2.8.6.1 Building MySQL Using VC++. To build from the BitKeeper tree, proceed to section 2.8.6.2 Creating a Windows Source Package from the Latest Development Source.
If you find something not working as expected, or you have
suggestions about ways to improve the current build process
on Windows, please send a message to the win32 mailing list.
See section 1.4.1.1 The MySQL Mailing Lists.
Note: VC++ workspace files for MySQL 4.1 and above are compatible with Microsoft Visual Studio 6.0 and above (7.0/.NET) editions and tested by MySQL AB staff before each release.
Follow this procedure to build MySQL:
WinZip or other Windows tool that can read `.zip' files.
File menu, select Open Workspace.
Build menu,
select the Set Active Configuration menu.
mysqld - Win32 Debug
and click OK.
F7 to begin the build of the debug server, libraries, and
some client applications.
Build All option from the Build menu.
--basedir and --datadir
options, or place appropriate options in an option file (the `my.ini'
file in your Windows directory or `C:\my.cnf'). If you have
an existing data directory elsewhere that you want to use, you can
specify its pathname instead.
mysql
interactive command-line utility that exists in your `client_release'
or `client_debug' directory.
When you are satisfied that the programs you have built are working correctly, stop the server. Then install MySQL as follows:
C:\> mkdir C:\mysql C:\> mkdir C:\mysql\bin C:\> mkdir C:\mysql\data C:\> mkdir C:\mysql\share C:\> mkdir C:\mysql\scriptsIf you want to compile other clients and link them to MySQL, you should also create several additional directories:
C:\> mkdir C:\mysql\include C:\> mkdir C:\mysql\lib C:\> mkdir C:\mysql\lib\debug C:\> mkdir C:\mysql\lib\optIf you want to benchmark MySQL, create this directory:
C:\> mkdir C:\mysql\sql-benchBenchmarking requires Perl support.
C:\mysql directory the
following directories:
C:\> cd \workdir C:\workdir> copy client_release\*.exe C:\mysql\bin C:\workdir> copy client_debug\mysqld.exe C:\mysql\bin\mysqld-debug.exe C:\workdir> xcopy scripts\*.* C:\mysql\scripts /E C:\workdir> xcopy share\*.* C:\mysql\share /EIf you want to compile other clients and link them to MySQL, you should also copy several libraries and header files:
C:\workdir> copy lib_debug\mysqlclient.lib C:\mysql\lib\debug C:\workdir> copy lib_debug\libmysql.* C:\mysql\lib\debug C:\workdir> copy lib_debug\zlib.* C:\mysql\lib\debug C:\workdir> copy lib_release\mysqlclient.lib C:\mysql\lib\opt C:\workdir> copy lib_release\libmysql.* C:\mysql\lib\opt C:\workdir> copy lib_release\zlib.* C:\mysql\lib\opt C:\workdir> copy include\*.h C:\mysql\include C:\workdir> copy libmysql\libmysql.def C:\mysql\includeIf you want to benchmark MySQL, you should also do this:
C:\workdir> xcopy sql-bench\*.* C:\mysql\bench /E
Set up and start the server in the same way as for the binary Windows distribution. See section 2.3 Installing MySQL on Windows.
To create a Windows source package from the current BitKeeper source tree, use the following instructions. Please note that this procedure must be performed on a system running a Unix or Unix-like operating system. For example, the procedure is known to work well on Linux.
shell> ./BUILD/compile-pentium-max
shell> ./scripts/make_win_src_distributionThis script creates a Windows source package to be used on your Windows system. You can supply different options to the script based on your needs. It accepts the following options:
--help
--debug
--tmp
--suffix
--dirname
--silent
--tar
make_win_src_distribution creates a Zip-format
archive with the name `mysql-VERSION-win-src.zip', where
VERSION represents the version of your MySQL source tree.
In your source files, you should include `my_global.h' before `mysql.h':
#include <my_global.h> #include <mysql.h>
`my_global.h' includes any other files needed for Windows compatibility (such as `windows.h') if you compile your program on Windows.
You can either link your code with the dynamic `libmysql.lib' library, which is just a wrapper to load in `libmysql.dll' on demand, or link with the static `mysqlclient.lib' library.
The MySQL client libraries are compiled as threaded libraries, so you should also compile your code to be multi-threaded.
After installing MySQL, there are some issues you should address. For example, on Unix, you should initialize the data directory and create the MySQL grant tables. On all platforms, an important security concern is that the initial accounts in the grant tables have no passwords. You should assign passwords to prevent unauthorized access to the MySQL server. For MySQL 4.1.3 and up, you can create time zone tables to enable recognition of named time zones. (Currently, these tables can be populated only on Unix. This problem will be addressed soon for Windows.)
The following sections include post-installation procedures that are specific to Windows systems and to Unix systems. Another section, section 2.9.2.3 Starting and Troubleshooting the MySQL Server, applies to all platforms; it describes what to do if you have trouble getting the server to start. section 2.9.3 Securing the Initial MySQL Accounts also applies to all platforms. You should follow its instructions to make sure that you have properly protected your MySQL accounts by assigning passwords to them.
When you are ready to create additional user accounts, you can find information on the MySQL access control system and account management in section 5.5 The MySQL Access Privilege System and section 5.6 MySQL User Account Management.
On Windows, the data directory and the grant tables do not have to be
created. MySQL Windows distributions include the grant tables with a set of
preinitialized accounts in the mysql database under the
data directory. You do not run the mysql_install_db script that
is used on Unix. However, if you did not install MySQL using the Windows Installation Wizard,
you should assign passwords to the accounts. See section 2.3.4.1 Introduction.
The procedure for this is given in section 2.9.3 Securing the Initial MySQL Accounts.
Before setting up passwords, you might want to try running some client programs to make sure that you can connect to the server and that it is operating properly. Make sure the server is running (see section 2.3.10 Starting the Server for the First Time), then issue the following commands to verify that you can retrieve information from the server. The output should be similar to what is shown here:
C:\> C:\mysql\bin\mysqlshow +-----------+ | Databases | +-----------+ | mysql | | test | +-----------+ C:\> C:\mysql\bin\mysqlshow mysql Database: mysql +--------------+ | Tables | +--------------+ | columns_priv | | db | | func | | host | | tables_priv | | user | +--------------+ C:\> C:\mysql\bin\mysql -e "SELECT Host,Db,User FROM db" mysql +------+-------+------+ | host | db | user | +------+-------+------+ | % | test% | | +------+-------+------+
If you are running a version of Windows that supports services and you want the MySQL server to run automatically when Windows starts, see section 2.3.12 Starting MySQL as a Windows Service.
After installing MySQL on Unix, you need to initialize the grant tables, start the server, and make sure that the server works okay. You may also wish to arrange for the server to be started and stopped automatically when your system starts and stops. You should also assign passwords to the accounts in the grant tables.
On Unix, the grant tables are set up by the mysql_install_db program.
For some installation methods, this program is run for you automatically:
mysql_install_db.
mysql_install_db.
Otherwise, you'll need to run mysql_install_db yourself.
The following procedure describes how to initialize the grant tables (if that has not previously been done) and then start the server. It also suggests some commands that you can use to test whether the server is accessible and working properly. For information about starting and stopping the server automatically, see section 2.9.2.2 Starting and Stopping MySQL Automatically.
After you complete the procedure and have the server running, you should
assign passwords to the accounts created by mysql_install_db.
Instructions for doing so are given in section 2.9.3 Securing the Initial MySQL Accounts.
In the examples shown here, the server runs under the user ID of the
mysql login account. This assumes that such an account exists.
Either create the account if it does not exist, or substitute the name of a
different existing login account that you plan to use for running the
server.
shell> cd BASEDIRBASEDIR is likely to be something like `/usr/local/mysql' or `/usr/local'. The following steps assume that you are located in this directory.
mysql_install_db program to set up the initial
MySQL grant tables containing the privileges that determine how users are
allowed to connect to the server. You'll need to do this if you used a
distribution type that doesn't run the program for you.
Typically, mysql_install_db needs to be run only the first time you
install MySQL, so you can skip this step if you are upgrading an existing
installation, However, mysql_install_db does not overwrite any
existing privilege tables, so it should be safe to run in any circumstances.
To initialize the grant tables, use one of the following commands,
depending on whether mysql_install_db is located in the bin
or scripts directory:
shell> bin/mysql_install_db --user=mysql shell> scripts/mysql_install_db --user=mysqlThe
mysql_install_db script creates the data directory, the
mysql database that holds all database privileges, and the test
database that you can use to test MySQL. The script also creates privilege
table entries for root accounts and anonymous-user accounts.
The accounts have no passwords initially. A description of their initial
privileges is given in section 2.9.3 Securing the Initial MySQL Accounts. Briefly, these privileges
allow the MySQL root user to do anything, and allow anybody to create
or use databases with a name of test or starting with test_.
It is important to make sure that the database directories and files are
owned by the mysql login account so that the server has read and
write access to them when you run it later. To ensure this, the --user
option should be used as shown if you run mysql_install_db as
root. Otherwise, you should execute the script while logged in as
mysql, in which case you can omit the --user option from the
command.
mysql_install_db creates several tables in the mysql database:
user, db, host, tables_priv,
columns_priv, func, and possibly others depending on your
version of MySQL.
If you don't want to have the test database, you can remove it with
mysqladmin -u root drop test after starting the server.
If you have problems with mysql_install_db, see
section 2.9.2.1 Problems Running mysql_install_db.
There are some alternatives to running the mysql_install_db
script as it is provided in the MySQL distribution:
mysql_install_db before you run it.
However, a preferable technique is to use GRANT and REVOKE to
change the privileges after the grant tables have been set up. In other
words, you can run mysql_install_db, and then use mysql -u root
mysql to connect to the server as the MySQL root user so that you
can issue the GRANT and REVOKE statements.
If you want to install MySQL on a lot of machines with the
same privileges, you can put the GRANT and REVOKE statements in
a file and execute the file as a script using mysql after running
mysql_install_db. For example:
shell> bin/mysql_install_db --user=mysql shell> bin/mysql -u root < your_script_fileBy doing this, you can avoid having to issue the statements manually on each machine.
GRANT and REVOKE and have made so many modifications
after running mysql_install_db that you want to wipe out the tables
and start over.
To re-create the grant tables, remove all the `.frm', `.MYI', and
`.MYD' files in the directory containing the mysql database.
(This is the directory named `mysql' under the data directory, which is
listed as the datadir value when you run mysqld --help.) Then
run the mysql_install_db script again.
Note: For MySQL versions older than 3.22.10, you should not
delete the `.frm' files. If you accidentally do this, you should copy
them back into the `mysql' directory from your MySQL distribution
before running mysql_install_db.
mysqld manually using the --skip-grant-tables
option and add the privilege information yourself using mysql:
shell> bin/mysqld_safe --user=mysql --skip-grant-tables & shell> bin/mysql mysqlFrom
mysql, manually execute the SQL commands contained in
mysql_install_db. Make sure that you run mysqladmin
flush-privileges or mysqladmin reload afterward to tell the server to
reload the grant tables.
Note that by not using mysql_install_db, you not only have to
populate the grant tables manually, you also have to create them first.
shell> bin/mysqld_safe --user=mysql &For versions of MySQL older than 4.0, substitute
bin/safe_mysqld
for bin/mysqld_safe in this command.
It is important that the MySQL server be run using an unprivileged
(non-root) login account. To ensure this, the --user
option should be used as shown if you run mysql_safe as
root. Otherwise, you should execute the script while logged in as
mysql, in which case you can omit the --user option from the
command.
Further instructions for running MySQL as an unprivileged user are given in
section A.3.2 How to Run MySQL as a Normal User.
If you neglected to create the grant tables before proceeding to this step,
the following message will appear in the error log file when you start the
server:
mysqld: Can't find file: 'host.frm'If you have other problems starting the server, see section 2.9.2.3 Starting and Troubleshooting the MySQL Server.
mysqladmin to verify that the server is running. The following
commands provide simple tests to check whether the server is up and responding
to connections:
shell> bin/mysqladmin version shell> bin/mysqladmin variablesThe output from
mysqladmin version varies slightly depending on your
platform and version of MySQL, but should be similar to that shown here:
shell> bin/mysqladmin version mysqladmin Ver 8.40 Distrib 4.0.18, for linux on i586 Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB This software comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to modify and redistribute it under the GPL license Server version 4.0.18-log Protocol version 10 Connection Localhost via Unix socket TCP port 3306 UNIX socket /tmp/mysql.sock Uptime: 16 sec Threads: 1 Questions: 9 Slow queries: 0 Opens: 7 Flush tables: 2 Open tables: 0 Queries per second avg: 0.000 Memory in use: 132K Max memory used: 16773KTo see what else you can do with
mysqladmin,
invoke it with the --help option.
shell> bin/mysqladmin -u root shutdown
mysqld_safe or
by invoking mysqld directly. For example:
shell> bin/mysqld_safe --user=mysql --log &If
mysqld_safe fails, see section 2.9.2.3 Starting and Troubleshooting the MySQL Server.
shell> bin/mysqlshow +-----------+ | Databases | +-----------+ | mysql | | test | +-----------+ shell> bin/mysqlshow mysql Database: mysql +--------------+ | Tables | +--------------+ | columns_priv | | db | | func | | host | | tables_priv | | user | +--------------+ shell> bin/mysql -e "SELECT Host,Db,User FROM db" mysql +------+--------+------+ | host | db | user | +------+--------+------+ | % | test | | | % | test_% | | +------+--------+------+
DBI DBD::mysql Data::Dumper Data::ShowTableThese modules can be obtained from CPAN (http://www.cpan.org/). See section 2.13.1 Installing Perl on Unix. The `sql-bench/Results' directory contains the results from many runs against different databases and platforms. To run all tests, execute these commands:
shell> cd sql-bench shell> perl run-all-testsIf you don't have the `sql-bench' directory, you probably installed MySQL using RPM files other than the source RPM. (The source RPM includes the `sql-bench' benchmark directory.) In this case, you must first install the benchmark suite before you can use it. Beginning with MySQL 3.22, there are separate benchmark RPM files named `mysql-bench-VERSION-i386.rpm' that contain benchmark code and data. If you have a source distribution, there are also tests in its `tests' subdirectory that you can run. For example, to run `auto_increment.tst', execute this command from the top-level directory of your source distribution:
shell> mysql -vvf test < ./tests/auto_increment.tstThe expected result of the test can be found in the `./tests/auto_increment.res' file.
As of MySQL 4.1.3, the installation procedure creates time zone tables
in the mysql database. However, you must populate the tables manually.
Instructions to do this are given in section 5.8.8 MySQL Server Time Zone Support.
mysql_install_db
The purpose of the mysql_install_db script is to generate new MySQL
privilege tables. It will not overwrite existing MySQL privilege tables,
and it will not affect any other data.
If you want to re-create your privilege tables, first stop
the mysqld server if it's running. Then rename the `mysql'
directory under the data directory to save it, and then run
mysql_install_db. For example:
shell> mv mysql-data-directory/mysql mysql-data-directory/mysql-old shell> mysql_install_db --user=mysql
This section lists problems you might encounter when you run
mysql_install_db:
mysql_install_db doesn't install the grant tables
mysql_install_db fails to install the grant
tables and terminates after displaying the following messages:
Starting mysqld daemon with databases from XXXXXX mysqld endedIn this case, you should examine the error log file very carefully. The log should be located in the directory `XXXXXX' named by the error message, and should indicate why
mysqld didn't start. If you don't understand
what happened, include the log when you post a bug report.
See section 1.4.1.3 How to Report Bugs or Problems.
mysqld process running
mysql_install_db at all because it need be run only once (when you
install MySQL the first time).
mysqld server doesn't work when one server is running
Can't start server: Bind on TCP/IP port: Address already in use Can't start server: Bind on unix socket...For instructions on setting up multiple servers, see section 5.10 Running Multiple MySQL Servers on the Same Machine.
mysql_install_db or the mysqld server.
You can specify different temporary directory and Unix socket file locations
by executing these commands prior to starting mysql_install_db or
mysqld:
shell> TMPDIR=/some_tmp_dir/ shell> MYSQL_UNIX_PORT=/some_tmp_dir/mysql.sock shell> export TMPDIR MYSQL_UNIX_PORT`some_tmp_dir' should be the full pathname to some directory for which you have write permission. After this, you should be able to run
mysql_install_db and start
the server with these commands:
shell> bin/mysql_install_db --user=mysql shell> bin/mysqld_safe --user=mysql &If
mysql_install_db is located in the `scripts' directory,
modify the first command to use scripts/mysql_install_db.
See section A.4.5 How to Protect or Change the MySQL Socket File `/tmp/mysql.sock'.
See section F Environment Variables.
Generally, you start the mysqld server in one of these ways:
mysqld directly. This works on any platform.
mysqld_safe, which tries to determine the proper options
for mysqld and then runs it with those options. This script is
used on systems based on BSD Unix.
See section 5.1.3 The mysqld_safe Server Startup Script.
mysql.server. This script is used primarily at
system startup and shutdown on systems that use System V-style run
directories, where it usually is installed under the name mysql.
The mysql.server script starts the server by invoking mysqld_safe.
See section 5.1.4 The mysql.server Server Startup Script.
mysql.server.
See section 2.5 Installing MySQL on Mac OS X for details.
The mysql.server and mysqld_safe scripts and the Mac OS X
Startup Item can be used to start the server manually, or automatically at
system startup time. mysql.server and the Startup Item also can be
used to stop the server.
To start or stop the server manually using the mysql.server script,
invoke it with start or stop arguments:
shell> mysql.server start shell> mysql.server stop
Before mysql.server starts the server, it changes location to the
MySQL installation directory, and then invokes mysqld_safe. If you
want the server to run as some specific user, add an appropriate user
option to the [mysqld] group of the `/etc/my.cnf' option file,
as shown later in this section.
(It is possible that you'll need to edit mysql.server
if you've installed a binary distribution of MySQL in a non-standard
location. Modify it to cd into the proper directory before it runs
mysqld_safe. If you do this, your modified version of
mysql.server may be overwritten if you upgrade MySQL in the future,
so you should make a copy of your edited version that you can reinstall.)
mysql.server stop brings down the server by sending a signal to it.
You can also stop the server manually by executing mysqladmin
shutdown.
To start and stop MySQL automatically on your server, you need to add start and stop commands to the appropriate places in your `/etc/rc*' files.
If you use the Linux server RPM package (MySQL-server-VERSION.rpm),
the mysql.server script will have been installed in the
`/etc/init.d' directory with the name `mysql'. You need not
install it manually. See section 2.4 Installing MySQL on Linux for more information on the Linux
RPM packages.
Some vendors provide RPM packages that install a startup script under a
different name such as mysqld.
If you install MySQL from a source distribution or using a binary
distribution format that does not install mysql.server automatically,
you can install it manually. The script can be found in the
`support-files' directory under the MySQL installation directory or in
a MySQL source tree.
To install mysql.server manually, copy it to the `/etc/init.d'
directory with the name mysql, and then make it executable. Do this
by changing location into the appropriate directory where
mysql.server is located and executing these commands:
shell> cp mysql.server /etc/init.d/mysql shell> chmod +x /etc/init.d/mysql
Older Red Hat systems use the `/etc/rc.d/init.d' directory rather than `/etc/init.d'. Adjust the preceding commands accordingly. Alternatively, first create `/etc/init.d' as a symbolic link that points to `/etc/rc.d/init.d':
shell> cd /etc shell> ln -s rc.d/init.d .
After installing the script, the commands needed to activate it to run
at system startup depend on your operating system. On Linux, you can use
chkconfig:
shell> chkconfig --add mysql
On some Linux systems, the following command also seems to be necessary to
fully enable the mysql script:
shell> chkconfig --level 345 mysql on
On FreeBSD, startup scripts generally should go in
`/usr/local/etc/rc.d/'. The rc(8) manual page states that
scripts in this directory are executed only if their basename matches the
*.sh shell filename pattern. Any other files or directories present
within the directory are silently ignored. In other words, on FreeBSD, you
should install the `mysql.server' script as
`/usr/local/etc/rc.d/mysql.server.sh' to enable automatic startup.
As an alternative to the preceding setup, some operating systems also use `/etc/rc.local' or `/etc/init.d/boot.local' to start additional services on startup. To start up MySQL using this method, you could append a command like the one following to the appropriate startup file:
/bin/sh -c 'cd /usr/local/mysql; ./bin/mysqld_safe --user=mysql &'
For other systems, consult your operating system documentation to see how to install startup scripts.
You can add options for mysql.server in a global
`/etc/my.cnf' file. A typical `/etc/my.cnf' file might look like
this:
[mysqld] datadir=/usr/local/mysql/var socket=/var/tmp/mysql.sock port=3306 user=mysql [mysql.server] basedir=/usr/local/mysql
The mysql.server script understands the following options:
basedir, datadir, and pid-file. If specified, they
must be placed in an option file, not on the command line.
mysql.server understands only start and stop as
command-line arguments.
The following table shows which option groups the server and each startup script read from option files:
| Script | Option Groups |
mysqld | [mysqld], [server], [mysqld-major-version]
|
mysql.server | [mysqld], [mysql.server]
|
mysqld_safe | [mysqld], [server], [mysqld_safe]
|
[mysqld-major-version] means that groups with names like
[mysqld-4.0], [mysqld-4.1], and [mysqld-5.0] will be
read by servers having versions 4.0.x, 4.1.x, 5.0.x, and so forth. This
feature was added in MySQL 4.0.14. It can be used to specify options that will
be read only by servers within a given release series.
For backward compatibility, mysql.server also reads the
[mysql_server] group and mysqld_safe also reads the
[safe_mysqld] group. However, you should update your option
files to use the [mysql.server] and [mysqld_safe] groups instead
when you begin using MySQL 4.0 or later.
See section 4.3.2 Using Option Files.
If you have problems starting the server, here are some things you can try:
Some storage engines have options that control their behavior.
You can create a `my.cnf' file and set startup options
for the engines you plan to use.
If you are going to use storage engines that support transactional tables
(InnoDB, BDB), be sure that you have them configured the
way you want before starting the server:
InnoDB tables, refer to the InnoDB-specific
startup options. In MySQL 3.23, you must configure InnoDB explicitly
or the server will fail to start. From MySQL 4.0 on, InnoDB uses default
values for its configuration options if you specify none.
See section 15.4 InnoDB Configuration.
BDB (Berkeley DB) tables, you should familiarize
yourself with the different BDB-specific startup options.
See section 14.4.3 BDB Startup Options.
When the mysqld server starts, it changes location to the data
directory. This is where it expects to find databases and where it expects
to write log files. On Unix, the server also writes the pid (process ID)
file in the data directory.
The data directory location is hardwired in when the server is compiled.
This is where the server looks for the data directory by default. If
the data directory is located somewhere else on your system, the server will
not work properly. You can find out what the default path settings are by
invoking mysqld with the --verbose and --help options.
(Prior to MySQL 4.1, omit the --verbose option.)
If the defaults don't match the MySQL installation layout on your system,
you can override them by specifying options on the command line to
mysqld or mysqld_safe. You can also list the options in an
option file.
To specify the location of the data directory explicitly, use the
--datadir option. However, normally you can tell mysqld the
location of the base directory under which MySQL is installed and it will
look for the data directory there. You can do this with the --basedir
option.
To check the effect of specifying path options, invoke mysqld with
those options followed by the --verbose and --help options.
For example, if you change location into the directory where mysqld is
installed, and then run the following command, it
will show the effect of starting the server with a base
directory of `/usr/local':
shell> ./mysqld --basedir=/usr/local --verbose --help
You can specify other options such as --datadir as well, but note
that --verbose and --help must be the last options. (Prior to
MySQL 4.1, omit the --verbose option.)
Once you determine the path settings you want, start the server without
--verbose and --help.
If mysqld is currently running, you can find out what path settings
it is using by executing this command:
shell> mysqladmin variables
Or:
shell> mysqladmin -h host_name variables
host_name is the name of the MySQL server host.
If you get Errcode 13 (which means Permission denied) when
starting mysqld, this means that the access privileges of the data
directory or its contents do not allow the server access. In this case, you
change the permissions for the involved files and directories so that the
server has the right to use them. You can also start the server as
root, but this can raise security issues and should be avoided.
On Unix, change location into the data directory and check the ownership of the data directory and its contents to make sure the server has access. For example, if the data directory is `/usr/local/mysql/var', use this command:
shell> ls -la /usr/local/mysql/var
If the data directory or its files or subdirectories are not owned by the account that you use for running the server, change their ownership to that account:
shell> chown -R mysql /usr/local/mysql/var shell> chgrp -R mysql /usr/local/mysql/var
If the server fails to start up correctly, check the error log file to
see if you can find out why. Log files are located in the data directory
(typically `C:\mysql\data' on Windows, `/usr/local/mysql/data'
for a Unix binary distribution, and `/usr/local/var' for a Unix source
distribution). Look in the data directory for files with names of the form
`host_name.err' and `host_name.log', where host_name is the
name of your server host. (Older servers on Windows use `mysql.err'
as the error log name.) Then check the last few lines of these files.
On Unix, you can use tail to display the last few lines:
shell> tail host_name.err shell> tail host_name.log
The error log contains information that indicates why the server couldn't start. For example, you might see something like this in the log:
000729 14:50:10 bdb: Recovery function for LSN 1 27595 failed 000729 14:50:10 bdb: warning: ./test/t1.db: No such file or directory 000729 14:50:10 Can't init databases
This means that you didn't start mysqld with the
--bdb-no-recover option and Berkeley DB found something wrong with
its own log files when it tried to recover your databases. To be able to
continue, you should move away the old Berkeley DB log files from the
database directory to some other place, where you can later examine them.
The BDB log files are named in sequence beginning with
`log.0000000001', where the number increases over time.
If you are running mysqld with BDB table support and
mysqld dumps core at startup, this could be due to problems with the
BDB recovery log. In this case, you can try starting mysqld
with --bdb-no-recover. If that helps, then you should remove
all BDB log files from the data directory and try starting mysqld
again without the --bdb-no-recover option.
If either of the following errors occur, it means that some other program
(perhaps another mysqld server) is using the TCP/IP port or
Unix socket file that mysqld is trying to use:
Can't start server: Bind on TCP/IP port: Address already in use Can't start server: Bind on unix socket...
Use ps to determine whether you have another mysqld server
running. If so, shut down the server before starting mysqld again.
(If another server is running, and you really want to run multiple servers,
you can find information about how to do so in section 5.10 Running Multiple MySQL Servers on the Same Machine.)
If no other server is running, try to execute the command telnet
your-host-name tcp-ip-port-number. (The default MySQL port number is
3306.) Then press Enter a couple of times. If you don't get an error
message like telnet: Unable to connect to remote host: Connection
refused, some other program is using the TCP/IP port that mysqld is
trying to use. You'll need to track down what program this is and disable
it, or else tell mysqld to listen to a different port with the
--port option. In this case, you'll also need to specify the port
number for client programs when connecting to the server via TCP/IP.
Another reason the port might be inaccessible is that you have a firewall running that blocks connections to it. If so, modify the firewall settings to allow access to the port.
If the server starts but you can't connect to it, you should make sure that you have an entry in `/etc/hosts' that looks like this:
127.0.0.1 localhost
This problem occurs only on systems that don't have a working thread library and for which MySQL must be configured to use MIT-pthreads.
If you can't get mysqld to start, you can try to make a trace file
to find the problem by using the --debug option.
See section E.1.2 Creating Trace Files.
See section 2.3.14 Troubleshooting a MySQL Installation Under Windows, for more information on troubleshooting Windows installations.
Part of the MySQL installation process is to set up the mysql database
containing the grant tables:
mysql_install_db
program. Some installation methods run this program for you. Others require
that you execute it manually. For details, see section 2.9.2 Unix Post-Installation Procedures.
The grant tables define the initial MySQL user accounts and their access privileges. These accounts are set up as follows:
root. These are
superuser accounts that can do anything. The initial root account
passwords are empty, so anyone can connect to the MySQL server as root
without a password and be granted all privileges.
root account is for connecting from the local host
and the other allows connections from any host.
root accounts are for connections from the local host.
Connections must be made from the local host by specifying a hostname of
localhost for one account, or the actual hostname or IP number for
the other.
root accounts.
The other is for connections from any host and has all privileges for the
test database or other databases with names that start with test.
localhost for one account, or the actual hostname or IP number for
the other. These accounts have all privileges for the test database
or other databases with names that start with test_.
As noted, none of the initial accounts have passwords. This means that your MySQL installation is unprotected until you do something about it:
root accounts.
The following instructions describe how to set up passwords for the
initial MySQL accounts, first for the anonymous accounts and then for the
root accounts. Replace ``newpwd'' in the examples with the
actual password that you want to use. The instructions also cover how
to remove the anonymous accounts, should you prefer not to allow anonymous
access at all.
You might want to defer setting the passwords until later, so that you don't need to specify them while you perform additional setup or testing. However, be sure to set them before using your installation for any real production work.
To assign passwords to the anonymous accounts, you can use either
SET PASSWORD or UPDATE. In both cases, be sure to encrypt the
password using the PASSWORD() function.
To use SET PASSWORD on Windows, do this:
shell> mysql -u root
mysql> SET PASSWORD FOR ''@'localhost' = PASSWORD('newpwd');
mysql> SET PASSWORD FOR ''@'%' = PASSWORD('newpwd');
To use SET PASSWORD on Unix, do this:
shell> mysql -u root
mysql> SET PASSWORD FOR ''@'localhost' = PASSWORD('newpwd');
mysql> SET PASSWORD FOR ''@'host_name' = PASSWORD('newpwd');
In the second SET PASSWORD statement, replace host_name
with the name of the server host. This is the name that is specified in
the Host column of the non-localhost record for root
in the user table. If you don't know what hostname this is, issue
the following statement before using SET PASSWORD:
mysql> SELECT Host, User FROM mysql.user;
Look for the record that has root in the User column and
something other than localhost in the Host column. Then use that
Host value in the second SET PASSWORD statement.
The other way to assign passwords to the anonymous accounts is by using
UPDATE to modify the user table directly. Connect to the
server as root and issue an UPDATE statement that assigns a
value to the Password column of the appropriate user table
records. The procedure is the same for Windows and Unix. The following
UPDATE statement assigns a password to both anonymous accounts at
once:
shell> mysql -u root
mysql> UPDATE mysql.user SET Password = PASSWORD('newpwd')
-> WHERE User = '';
mysql> FLUSH PRIVILEGES;
After you update the passwords in the user table directly using
UPDATE, you must tell the server to re-read the grant tables with
FLUSH PRIVILEGES. Otherwise, the change will go unnoticed until you
restart the server.
If you prefer to remove the anonymous accounts instead, do so as follows:
shell> mysql -u root mysql> DELETE FROM mysql.user WHERE User = ''; mysql> FLUSH PRIVILEGES;
The DELETE statement applies both to Windows and to Unix.
On Windows, if you want to remove only the anonymous account that has the same
privileges as root, do this instead:
shell> mysql -u root mysql> DELETE FROM mysql.user WHERE Host='localhost' AND User=''; mysql> FLUSH PRIVILEGES;
This account allows anonymous access but has full privileges, so removing it improves security.
You can assign passwords to the root accounts in several ways. The
following discussion demonstrates three methods:
SET PASSWORD statement
mysqladmin command-line client program
UPDATE statement
To assign passwords using SET PASSWORD, connect to the server as
root and issue two SET PASSWORD statements.
Be sure to encrypt the password using the PASSWORD() function.
For Windows, do this:
shell> mysql -u root
mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('newpwd');
mysql> SET PASSWORD FOR 'root'@'%' = PASSWORD('newpwd');
For Unix, do this:
shell> mysql -u root
mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('newpwd');
mysql> SET PASSWORD FOR 'root'@'host_name' = PASSWORD('newpwd');
In the second SET PASSWORD statement, replace host_name with
the name of the server host. This is the same hostname that you used when
you assigned the anonymous account passwords.
To assign passwords to the root accounts using mysqladmin,
execute the following commands:
shell> mysqladmin -u root password "newpwd" shell> mysqladmin -u root -h host_name password "newpwd"
These commands apply both to Windows and to Unix. In the second command, replace host_name with the name of the server host. The double quotes around the password are not always necessary, but you should use them if the password contains spaces or other characters that are special to your command interpreter.
If you are using a server from a very old version of MySQL, the
mysqladmin commands to set the password will fail with the message
parse error near 'SET password'. The solution to this problem is
to upgrade the server to a newer version of MySQL.
You can also use UPDATE to modify the user table directly.
The following UPDATE statement assigns a password to both root
accounts at once:
shell> mysql -u root
mysql> UPDATE mysql.user SET Password = PASSWORD('newpwd')
-> WHERE User = 'root';
mysql> FLUSH PRIVILEGES;
The UPDATE statement applies both to Windows and to Unix.
After the passwords have been set, you must supply the appropriate
password whenever you connect to the server.
For example, if you want to use mysqladmin to shut
down the server, you can do so using this command:
shell> mysqladmin -u root -p shutdown Enter password: (enter root password here)
Note: If you forget your root password after setting it up,
the procedure for resetting it is covered in section A.4.1 How to Reset the Root Password.
To set up new accounts, you can use the GRANT statement. For
instructions, see section 5.6.2 Adding New User Accounts to MySQL.
As a general rule, we recommend that when upgrading from one release series to another, you should go to the next series rather than skipping a series. For example, if you currently are running MySQL 3.23 and wish to upgrade to a newer series, upgrade to MySQL 4.0 rather than to 4.1 or 5.0.
The following items form a checklist of things you should do whenever you perform an upgrade:
mysql database. Occasionally new columns or tables are added to
support new features. To take advantage of these features, be sure that
your grant tables are up to date. The upgrade procedure is described in
section 2.10.7 Upgrading the Grant Tables.
mysqld-max, then upgrade later to a non-Max version of MySQL,
mysqld_safe will still attempt to run the old mysqld-max
server. If you perform such an upgrade, you should manually remove the old
mysqld-max server to ensure that mysqld_safe runs the new
mysqld server.
You can always move the MySQL format files and data files between different
versions on the same architecture as long as you stay within versions for
the same release series of MySQL. The current production release series is
4.1. If you change the character set when running MySQL, you must run
myisamchk -r -q --set-character-set=charset on all MyISAM tables.
Otherwise, your indexes may not be ordered correctly, because changing the
character set may also change the sort order.
Normally you can upgrade MySQL to a newer MySQL version without having
to do any changes to your tables. Please confirm if the upgrade notes
to the particular version you are upgrading to tells you anything about
this. If there would be any incompatibilities you can use
mysqldump to dump your tables before upgrading. After
upgrading, reload the dump file using mysql or mysqlimport
to re-create your tables.
If you are cautious about using new versions, you can always rename your old
mysqld before installing a newer one. For example, if you are using
MySQL 4.0.18 and want to upgrade to 4.1.1, rename your current server from
mysqld to mysqld-4.0.18. If your new mysqld then does
something unexpected, you can simply shut it down and restart with your old
mysqld.
If, after an upgrade, you experience problems with recompiled client programs,
such as Commands out of sync or unexpected core dumps, you probably have
used old header or library files when compiling your programs. In this
case, you should check the date for your `mysql.h' file and
`libmysqlclient.a' library to verify that they are from the new
MySQL distribution. If not, recompile your programs with the new
headers and libraries.
If problems occur, such as that the new mysqld server doesn't want to
start or that you can't connect without a password, verify that you don't
have some old `my.cnf' file from your previous installation. You can
check this with the --print-defaults option (for example,
mysqld --print-defaults). If this displays
anything other than the program name, you have an active `my.cnf'
file that affects server or client operation.
It is a good idea to rebuild and reinstall the Perl DBD::mysql
module whenever you install a new release of MySQL. The same applies to other
MySQL interfaces as well, such as the PHP mysql extension and the
Python MySQLdb module.
In general, you should do the following when upgrading to MySQL 5.0 from 4.1:
proc table in the mysql database.
To create this file, you should run the mysql_fix_privilege_tables
script as described in section 2.10.7 Upgrading the Grant Tables.
user and db tables in the mysql database.
To create these columns, you should run the mysql_fix_privilege_tables
script as described in section 2.10.7 Upgrading the Grant Tables.
'2004-02-31', you should start
the server with --sql_mode=TRADITIONAL,ALLOW_INVALID_DATES.
SCHEMA and SCHEMAS keywords are
accepted as synonyms for DATABASE and DATABASES.
The following list describes changes that may affect applications and that you should watch out for when upgrading to version 5.0:
SET @x = 0; SET @X = 1; SELECT @x; creates two variables and
returns 0. In MySQL 5.0, it creates one variable and returns
1.
reconnect flag in the MYSQL structure is set
to 0 by mysql_real_connect(). Only those client programs which didn't
explicitly set this flag to 0 or 1 after mysql_real_connect() will
experience a change. Having automatic reconnection enabled by default was
considered too dangerous (after reconnection, table locks, temporary tables,
user and session variables are lost).
In general, you should do the following when upgrading to MySQL 4.1 from 4.0:
UTF8. If you have
table names or column names that use characters outside of the standard 7-bit
US-ASCII range, you may have to do a mysqldump of your tables
in MySQL 4.0 and restore them after upgrading to MySQL 4.1. The symptom for
this problem is that you get a table not found error when trying to
access your tables. In this case, you should be able to downgrade back to
MySQL 4.0 and access your data.
Password column that is needed for more secure handling of passwords.
The procedure uses mysql_fix_privilege_tables and is described
in section 2.10.7 Upgrading the Grant Tables. If you don't do this, MySQL will not
use the new more secure protocol to authenticate. Implications of the
password-handling change for applications are given later in this section.
mysqldump to dump your BDB tables in text format and delete
all log.XXXXXXXXXX files before you start MySQL 4.0 and reload
the data.
mysql database.
For instructions, see section 2.9 Post-Installation Setup and Testing.
DBD-mysql module
(Msql-MySQL-modules) you have to upgrade to use the newer
DBD-mysql module. Anything above DBD-mysql 2.xx should be fine.
If you don't upgrade, some methods (such as DBI->do()) will not
notice error conditions correctly.
--defaults-file=option-file-name option will give an error if
the option file doesn't exist.
Several visible behaviors have changed between MySQL 4.0 and MySQL 4.1 to fix some critical bugs and make MySQL more compatible with standard SQL. These changes may affect your applications.
Some of the 4.1 behaviors can be tested in 4.0 before performing
a full upgrade to 4.1. We have added to later MySQL 4.0 releases
(from 4.0.12 on) a --new startup option for mysqld.
See section 5.2.1 mysqld Command-Line Options.
This option gives you the 4.1 behavior for the most critical changes.
You can also enable these behaviors for a given client connection with
the SET @@new=1 command, or turn them off if they are on with
SET @@new=0.
If you believe that some of the 4.1 changes will affect you,
we recommend that before upgrading to 4.1, you download
the latest MySQL 4.0 version and run it with the --new option by
adding the following to your config file:
[mysqld-4.0] new
That way you can test the new behaviors in 4.0 to make sure that your
applications work with them. This will help you have a smooth, painless
transition when you perform a full upgrade to 4.1 later. Putting the
--new option in the [mysqld-4.0] option group ensures
that you don't accidentally later run the 4.1
version with the --new option.
The following lists describe changes that may affect applications and that you should watch out for when upgrading to version 4.1:
Server Changes:
SHOW CREATE TABLE and mysqldump.
(MySQL versions 4.0.6 and above can read the new dump files; older
versions cannot.)
This change should not affect applications that use only one character set.
mysqldump
and reload the dump file. Some items in the following list indicate
alternatives means for rebuilding.
InnoDB tables with TIMESTAMP
columns in MySQL versions 4.1.0 to 4.1.3, you have to rebuild those tables
when you upgrade to MySQL 4.1.4 or later. The storage format in those
MySQL versions for a TIMESTAMP column was incorrect. If you upgrade
from MySQL 4.0 to 4.1.4 or later, then no rebuild of tables with
TIMESTAMP columns is needed.
InnoDB uses the same character set
comparison functions as MySQL for non-latin1_swedish_ci character
strings that are not BINARY. This changes the sorting order of
space and characters with a code < ASCII(32) in those character sets.
For latin1_swedish_ci character strings and BINARY strings,
InnoDB uses its own pad-spaces-at-end comparison method, which
stays unchanged. If you have an InnoDB table created with MySQL
4.1.2 or earlier, with an index on a non-latin1 character set
(in the case of 4.1.0 and 4.1.1, with any character set) and the table
contains any CHAR/VARCHAR/or TEXT columns that are
not BINARY but may contain characters with a code < ASCII(32),
then you should do ALTER TABLE or OPTIMIZE TABLE on it to
regenerate the index, after upgrading to MySQL 4.1.3 or later.
Also, MyISAM tables have to be rebuilt or repaired in these cases.
RENAME
TABLE to overcome this if the accent character is in the table name or
the database name, or rebuild the table.
CHAR(N) means N characters, not N
bytes.
For single-byte character sets, this change makes no difference. However,
if you upgrade to MySQL 4.1 and configure the server to use a multi-byte
character set, the apparent length of character columns will change. Suppose
that a 4.0 table contains a CHAR(8) column used to store ujis
characters. Eight bytes can store from two to four ujis characters.
If you upgrade to 4.1 and configure the server to use ujis as its
default character set, the server interprets character column lengths
based on the maximum size of a ujis character, which is three
bytes. The number of three-byte characters that fit in eight bytes is
two. Consequently, if you use SHOW CREATE TABLE to view the table
definition, MySQL displays CHAR(2). You can retrieve existing
data from the table, but you will be able to store new values containing
only up to two characters. To correct this issue, use ALTER TABLE
to change the column definition. For example:
ALTER TABLE tbl_name MODIFY col_name CHAR(8);
mysqldump.
See section 8.8 The mysqldump Database Backup Program.
InnoDB is not aware of multiple tablespaces.
timezone system variable was renamed to system_time_zone.
--shared-memory option. If you are running
multiple servers this way on the same Windows machine, you should use a
different --shared-memory-base-name option for each server.
xxx_clear() function for each aggregate function XXX().
Client Changes:
mysqldump has the --opt and --quote-names options
enabled by default. You can turn them off with --skip-opt and
--skip-quote-names.
SQL Changes:
Type column in the output from SHOW TABLE
STATUS was renamed to Engine.
'a' > 'a\t',
which it wasn't before. If you have any tables where you
have a CHAR or VARCHAR column in which the last character in the
column may be less than ASCII(32), you should use REPAIR TABLE or
myisamchk to ensure that the table is correct.
DELETE statements, you should use the
alias of the tables from which you want to delete, not the actual table name.
For example, instead of doing this:
DELETE test FROM test AS t1, test2 WHERE ...Do this:
DELETE t1 FROM test AS t1, test2 WHERE ...This corrects a problem that was present in MySQL 4.0.
TIMESTAMP is returned as a string in 'YYYY-MM-DD HH:MM:SS'
format (from 4.0.12 the --new option can be used to make a
4.0 server behave as 4.1 in this respect).
See section 11.3.1.2 TIMESTAMP Properties as of MySQL 4.1.
If you want to have the value returned as a number (as MySQL 4.0 does) you
should add +0 to TIMESTAMP columns when you retrieve them:
mysql> SELECT ts_col + 0 FROM tbl_name;Display widths for
TIMESTAMP columns are no longer supported.
For example, if you declare a column as TIMESTAMP(10), the (10)
is ignored.
These changes were necessary for SQL standards compliance. In a future
version, a further change will be made (backward compatible with this
change), allowing the timestamp length to indicate the desired number of
digits for fractions of a second.
0xFFDF are assumed to be strings instead of
numbers. This fixes some problems with character sets where it's
convenient to input a string as a binary value. With this change,
you should use CAST() if you want to compare binary values
numerically as integers:
mysql> SELECT CAST(0xFEFF AS UNSIGNED INTEGER)
-> < CAST(0xFF AS UNSIGNED INTEGER);
-> 0
If you don't use CAST(), a lexical string comparison will be done:
mysql> SELECT 0xFEFF < 0xFF;
-> 1
Using binary items in a numeric context or comparing them using the
= operator should work as before. (The --new option can
be used from 4.0.13 on to make a 4.0 server behave as 4.1 in this respect.)
DATE, DATETIME, or TIME
value, the result returned to the client is fixed up to have a temporal
type. For example, in MySQL 4.1, you get this result:
mysql> SELECT CAST('2001-1-1' AS DATETIME);
-> '2001-01-01 00:00:00'
In MySQL 4.0, the result is different:
mysql> SELECT CAST('2001-1-1' AS DATETIME);
-> '2001-01-01'
DEFAULT values no longer can be specified for AUTO_INCREMENT
columns. (In 4.0, a DEFAULT value is silently ignored; in 4.1,
an error occurs.)
LIMIT no longer accepts negative arguments.
Use some large number (maximum 18446744073709551615) instead of -1.
SERIALIZE is no longer a valid mode value for the sql_mode
variable. You should use SET TRANSACTION ISOLATION LEVEL SERIALIZABLE
instead. SERIALIZE is no longer valid for the --sql-mode option
for mysqld, either. Use --transaction-isolation=SERIALIZABLE
instead.
INSERT INTO t (datetime_col) VALUES ('stuff 2005-02-11 10:17:01');
As of MySQL 4.1.1, the parser is more strict and treats the string as an
invalid date, so the preceding statement results in a warning.
C API Changes:
mysql_shutdown() C API function has an extra parameter
as of MySQL 4.1.3: SHUTDOWN-level. You should convert any
mysql_shutdown(X) call you have in your application to
mysql_shutdown(X,SHUTDOWN_DEFAULT).
mysql_real_query() return 1 on error,
not -1. You may have to change some old applications if they use
constructs like this:
if (mysql_real_query(mysql_object, query, query_length) == -1)
{
printf("Got error");
}
Change the call to test for a non-zero value instead:
if (mysql_real_query(mysql_object, query, query_length) != 0)
{
printf("Got error");
}
Password-Handling Changes:
The password hashing mechanism has changed in 4.1 to provide better security, but this may cause compatibility problems if you still have clients that use the client library from 4.0 or earlier. (It is very likely that you will have 4.0 clients in situations where clients connect from remote hosts that have not yet upgraded to 4.1.) The following list indicates some possible upgrade strategies. They represent various tradeoffs between the goal of compatibility with old clients and the goal of security.
mysql_fix_privilege_tables script to
widen the Password column in the user table so that it can
hold long password hashes. But run the server with the
--old-passwords option to provide backward compatibility that allows
pre-4.1 clients to continue to connect to their short-hash accounts.
Eventually, when all your clients are upgraded to 4.1, you can stop using
the --old-passwords server option. You can also change the passwords
for your MySQL accounts to use the new more secure format. A pure-4.1
installation is the most secure.
Further background on password hashing with respect to client authentication
and password-changing operations may be found in section 5.5.9 Password Hashing in MySQL 4.1 and
section A.2.3 Client does not support authentication protocol.
In general, you should do the following when upgrading to MySQL 4.0 from 3.23:
mysql_fix_privilege_tables script and is described
in section 2.10.7 Upgrading the Grant Tables.
ISAM files to MyISAM files. One way to do this
is with the
mysql_convert_table_format script. (This is a Perl script;
it requires that DBI be installed.) To convert the tables in a given database,
use this command:
shell> mysql_convert_table_format database db_nameNote that this should be used only if all tables in the given database are
ISAM or MyISAM tables. To avoid converting tables
of other types to MyISAM, you can explicitly list the names
of your ISAM tables after the database name on the command
line.
Individual tables can be changed to MyISAM by using the following
ALTER TABLE statement for each table to be converted:
mysql> ALTER TABLE tbl_name TYPE=MyISAM;If you are not sure of the table type for a given table, use this statement:
mysql> SHOW TABLE STATUS LIKE 'tbl_name';
DBD::mysql module). If you do, you should recompile
them, because the data structures used in `libmysqlclient.so' have changed.
The same applies to other MySQL interfaces as well, such as the Python
MySQLdb module.
MySQL 4.0 will work even if you don't perform the preceding actions, but you
will not be able to use the new security privileges in MySQL 4.0 and you
may run into problems when upgrading later to MySQL 4.1 or newer. The
ISAM file format still works in MySQL 4.0, but is deprecated and
is not compiled in by default as of MySQL 4.1. MyISAM tables should
be used instead.
Old clients should work with a MySQL 4.0 server without any problems.
Even if you perform the preceding actions, you can still downgrade to MySQL
3.23.52 or newer if you run into problems with the MySQL 4.0 series. In
this case, you must use mysqldump to dump any tables that use
full-text indexes and reload the dump file into the 3.23 server. This is
necessary because 4.0 uses a new format for full-text indexing.
The following lists describe changes that may affect applications and that you should watch out for when upgrading to version 4.0:
Server Changes:
mysql.user table.
See section 5.5.3 Privileges Provided by MySQL.
To get these new privileges to work, you must update the grant tables.
The procedure is described in section 2.10.7 Upgrading the Grant Tables.
Until you do this, all
accounts have the SHOW DATABASES, CREATE TEMPORARY TABLES,
and LOCK TABLES privileges. SUPER and EXECUTE
privileges take their value from PROCESS.
REPLICATION SLAVE and REPLICATION CLIENT take their
values from FILE.
If you have any scripts that create new MySQL user accounts, you may want to change
them to use the new privileges. If you are not using GRANT
commands in the scripts, this is a good time to change your scripts to use
GRANT instead of modifying the grant tables directly.
From version 4.0.2 on, the option --safe-show-database is deprecated
(and no longer does anything). See section 5.4.3 Startup Options for mysqld Concerning Security.
If you get Access denied errors for new users in version 4.0.2 and up, you
should check whether you need some of the new grants that you didn't need
before. In particular, you will need REPLICATION SLAVE
(instead of FILE) for new slave servers.
safe_mysqld has been renamed to mysqld_safe. For backward
compatibility, binary distributions will for some time include
safe_mysqld as a symlink to mysqld_safe.
InnoDB support is included by default in binary distributions.
If you build MySQL from source, InnoDB is configured in by default.
If you do not use InnoDB and want to save memory when running a
server that has InnoDB support enabled, use the --skip-innodb
server startup option. To compile MySQL without InnoDB support, run
configure with the --without-innodb option.
myisam_max_extra_sort_file_size and
myisam_max_extra_sort_file_size are given in bytes
(they were given in megabytes before 4.0.3).
mysqld has the option --temp-pool enabled by default
because this gives better performance with some operating systems (most
notably Linux).
mysqld startup options --skip-locking and
--enable-locking were renamed to --skip-external-locking
and --external-locking.
MyISAM/ISAM files is
turned off by default. You can turn this on with
--external-locking. (However, this is never needed for most users.)
| Old Name | New Name |
myisam_bulk_insert_tree_size | bulk_insert_buffer_size
|
query_cache_startup_type | query_cache_type
|
record_buffer | read_buffer_size
|
record_rnd_buffer | read_rnd_buffer_size
|
sort_buffer | sort_buffer_size
|
warnings | log-warnings
|
--err-log | --log-error (for mysqld_safe)
|
record_buffer, sort_buffer, and
warnings will still work in MySQL 4.0 but are deprecated.
SQL Changes:
| Old Name | New Name |
SQL_BIG_TABLES | BIG_TABLES
|
SQL_LOW_PRIORITY_UPDATES | LOW_PRIORITY_UPDATES
|
SQL_MAX_JOIN_SIZE | MAX_JOIN_SIZE
|
SQL_QUERY_CACHE_TYPE | QUERY_CACHE_TYPE
|
SET GLOBAL SQL_SLAVE_SKIP_COUNTER=skip_count instead of
SET SQL_SLAVE_SKIP_COUNTER=skip_count.
SHOW MASTER STATUS returns an empty set if binary logging is not
enabled.
SHOW SLAVE STATUS returns an empty set if the slave is not
initialized.
SHOW INDEX has two more columns than it had in 3.23 (Null and
Index_type).
SHOW OPEN TABLES has changed.
ORDER BY col_name DESC sorts NULL values last, as of
MySQL 4.0.11. In 3.23 and in earlier 4.0 versions, this was not
always consistent.
CHECK, LOCALTIME, and LOCALTIMESTAMP
are reserved words.
DOUBLE and FLOAT columns honor the
UNSIGNED flag on storage (before, UNSIGNED was ignored for
these columns).
|, &, <<,
>>, and ~) is unsigned. This may cause problems if you
are using them in a context where you want a signed result.
See section 12.7 Cast Functions and Operators.
Note: When you use subtraction between integer values where
one is of type UNSIGNED, the result will be unsigned. In other
words, before upgrading to MySQL 4.0, you should check your application
for cases in which you are subtracting a value from an unsigned entity and
want a negative answer or subtracting an unsigned value from an
integer column. You can disable this behavior by using the
--sql-mode=NO_UNSIGNED_SUBTRACTION option when starting
mysqld. See section 5.2.2 The Server SQL Mode.
BIGINT columns (instead
of using strings, as you did in MySQL 3.23). Using strings will still
work, but using integers is more efficient.
INSERT INTO ... SELECT always had IGNORE enabled.
As of 4.0.1, MySQL will stop (and possibly roll back) by default in case of
an error unless you specify IGNORE.
TRUNCATE TABLE when you want to delete all rows
from a table and you don't need to obtain a count of the number of rows
that were deleted. (DELETE FROM tbl_name returns a row count in
4.0 and doesn't reset the AUTO_INCREMENT counter, and
TRUNCATE TABLE is faster.)
LOCK TABLES
statement when trying to execute TRUNCATE TABLE or DROP
DATABASE.
MATCH ... AGAINST (... IN BOOLEAN MODE) full-text searches
with your tables, you must rebuild their indexes with REPAIR TABLE
tbl_name USE_FRM. If you attempt a boolean full-text search without
rebuilding the indexes this way, the search will return incorrect results.
See section 12.6.4 Fine-Tuning MySQL Full-Text Search.
LOCATE() and INSTR() are case sensitive if one of the
arguments is a binary string. Otherwise they are case insensitive.
STRCMP() uses the current character set when performing comparisons.
This makes the default comparison behavior not case sensitive unless
one or both of the operands are binary strings.
HEX(str) returns the characters in str converted to
hexadecimal. If you want to convert a number to hexadecimal, you should
ensure that you call HEX() with a numeric argument.
RAND(seed) returns a different random number series in 4.0 than in
3.23; this was done to further differentiate RAND(seed) and
RAND(seed+1).
IFNULL(A,B) is set to be the
more ``general'' of the types of A and B. (The general-to-specific
order is string, REAL, INTEGER).
C API Changes:
mysql_drop_db(), mysql_create_db(), and
mysql_connect() are no longer supported unless you compile
MySQL with CFLAGS=-DUSE_OLD_FUNCTIONS. However, it is preferable
to change client programs to use the new 4.0 API instead.
MYSQL_FIELD structure, length and max_length have
changed from unsigned int to unsigned long. This should not
cause any problems, except that they may generate warning messages when
used as arguments in the printf() class of functions.
mysql_thread_init() and
mysql_thread_end(). See section 22.2.15 How to Make a Threaded Client.
Other Changes:
DBD::mysql module, use a recent
version. Version 2.9003 is recommended. Versions older than 1.2218 should
not be used because they use the deprecated mysql_drop_db() call.
MySQL 3.22 and 3.21 clients will work without any problems with a MySQL 3.23 server.
When upgrading to MySQL 3.23 from an earlier version, note the following changes:
Table Changes:
MyISAM type and the old
ISAM type. By default, all new tables are created with type
MyISAM unless you start mysqld with the
--default-table-type=isam option. You don't have to convert your old
ISAM tables to use them with MySQL 3.23. You can convert an
ISAM table to MyISAM format with ALTER TABLE tbl_name
TYPE=MyISAM or the Perl script mysql_convert_table_format.
tis620 character set must be fixed
with myisamchk -r or REPAIR TABLE.
german character sort order for ISAM
tables, you must repair them with isamchk -r, because we have made
some changes in the sort order.
Client Program Changes:
mysql is by default started with the
--no-named-commands (-g) option. This option can be disabled with
--enable-named-commands (-G). This may cause incompatibility problems in
some cases--for example, in SQL scripts that use named commands without a
semicolon. Long format commands still work from the first line.
mysqldump files to be compatible between
MySQL 3.22 and 3.23, you should not use the
--opt or --all option to mysqldump.
SQL Changes:
DROP DATABASE on a symbolically linked database, both the
link and the original database are deleted. This didn't happen in MySQL 3.22
because configure didn't detect the availability of the
readlink() system call.
OPTIMIZE TABLE works only for MyISAM tables.
For other table types, you can use ALTER TABLE to optimize the table.
During OPTIMIZE TABLE, the table is locked to prevent it from being
used by other threads.
MONTH()) will
return 0 for 0000-00-00 dates. In MySQL 3.22, these functions returned
NULL.
IF() depends on both arguments,
not just the first one.
AUTO_INCREMENT columns should not be used to store negative
numbers. The reason for this is that negative numbers caused problems
when wrapping from -1 to 0. You should not store 0 in AUTO_INCREMENT
columns, either; CHECK TABLE will complain about 0 values because
they may change if you dump and restore the table. AUTO_INCREMENT
for MyISAM tables is handled at a lower level and is much
faster than before. In addition, for MyISAM tables, old numbers
are not reused, even if you delete rows from the table.
CASE, DELAYED, ELSE, END, FULLTEXT,
INNER, RIGHT, THEN, and WHEN are reserved words.
FLOAT(p) is a true floating-point type and not a value with a
fixed number of decimals.
DECIMAL(length,dec) type, the
length argument no longer includes a place for the sign or the
decimal point.
TIME string must be of one of the following formats:
[[[DAYS] [H]H:]MM:]SS[.fraction] or
[[[[[H]H]H]H]MM]SS[.fraction].
LIKE compares strings using the same character comparison rules
as for the = operator. If you require the old behavior, you can
compile MySQL with the CXXFLAGS=-DLIKE_CMP_TOUPPER flag.
REGEXP is case insensitive if neither of the strings is a binary
string.
MyISAM (`.MYI') tables, you should use
the CHECK TABLE statement or the myisamchk command. For
ISAM (`.ISM') tables, use the isamchk command.
DATE_FORMAT() to make sure that there is a
`%' before each format character.
SELECT DISTINCT ... was
almost always sorted. In MySQL 3.23, you must use GROUP BY or
ORDER BY to obtain sorted output.
SUM() returns NULL instead of 0 if
there are no matching rows. This is required by standard SQL.
AND or OR with NULL values will return
NULL instead of 0. This mostly affects queries that use NOT
on an AND/OR expression as NOT NULL = NULL.
LPAD() and RPAD() shorten the result string if it's longer
than the length argument.
C API Changes:
mysql_fetch_fields_direct() is a function instead of a macro.
It returns a pointer to a MYSQL_FIELD instead of a
MYSQL_FIELD.
mysql_num_fields() cannot be used on a MYSQL* object (it's
a function that takes a MYSQL_RES* value as an argument). With a
MYSQL* object, you should use mysql_field_count() instead.
Nothing that affects compatibility has changed between versions 3.21 and 3.22.
The only pitfall is that new tables that are created with DATE type
columns will use the new way to store the date. You can't access these new
columns from an old version of mysqld.
When upgrading to MySQL 3.23 from an earlier version, note the following changes:
mysql_fix_privilege_tables script. This will add the
new privileges that you need to use the GRANT command. If you forget
this, you will get Access denied when you try to use ALTER
TABLE, CREATE INDEX, or DROP INDEX. The procedure for updating
the grant tables is described in section 2.10.7 Upgrading the Grant Tables.
mysql_real_connect() has changed. If you have
an old client program that calls this function, you must pass a 0 for
the new db argument (or recode the client to send the db
element for faster connections). You must also call mysql_init()
before calling mysql_real_connect(). This change was done to allow
the new mysql_options() function to save options in the MYSQL
handler structure.
mysqld variable key_buffer has been renamed to
key_buffer_size, but you can still use the old name in your
startup files.
If you are running a version older than Version 3.20.28 and want to switch to Version 3.21, you need to do the following:
You can start the mysqld Version 3.21 server with the
--old-protocol option to use it with clients from a Version 3.20
distribution. In this case, the server uses the old pre-3.21
password() checking rather than the new method. Also, the new client
function mysql_errno() will not return any server error, only
CR_UNKNOWN_ERROR. The function does work for client errors.
If you are not using the --old-protocol option to
mysqld, you will need to make the following changes:
scripts/add_long_password script must be run to convert the
Password field in the mysql.user table to CHAR(16).
mysql.user table to get 62-bit
rather than 31-bit passwords.
MySQL 3.20.28 and above can handle the new user table
format without affecting clients. If you have a MySQL version earlier
than 3.20.28, passwords will no longer work with it if you convert the
user table. So to be safe, you should first upgrade to at least Version
3.20.28 and then upgrade to Version 3.21.
The new client code works with a 3.20.x mysqld server, so
if you experience problems with 3.21.x, you can use the old 3.20.x server
without having to recompile the clients again.
If you are not using the --old-protocol option to mysqld,
old clients will be unable to connect and will issue the following error
message:
ERROR: Protocol mismatch. Server Version = 10 Client Version = 9
The Perl DBI interface also supports the old
mysqlperl interface. The only change you have to make if you use
mysqlperl is to change the arguments to the connect() function.
The new arguments are: host, database, user,
and password (note that the user and password arguments
have changed places).
The following changes may affect queries in old applications:
HAVING must be specified before any ORDER BY clause.
LOCATE() have been swapped.
DATE,
TIME, and TIMESTAMP.
Some releases introduce changes to the structure of the grant tables
(the tables in the mysql database)
to add new privileges or features. To make sure that your grant tables
are current when you update to a new version of MySQL, you should update
your grant tables as well.
On Unix or Unix-like systems, update the grant tables by running the
mysql_fix_privilege_tables script:
shell> mysql_fix_privilege_tables
You must run this script while the server is running. It attempts to
connect to the server running on the local host as root.
If your root account requires a password, indicate the password
on the command line. For MySQL 4.1 and up, specify the password like this:
shell> mysql_fix_privilege_tables --password=root_password
Prior to MySQL 4.1, specify the password like this:
shell> mysql_fix_privilege_tables root_password
The mysql_fix_privilege_tables script performs any actions
necessary to convert your grant tables to the current format. You
might see some Duplicate column name warnings as it runs; you can
ignore them.
After running the script, stop the server and restart it.
On Windows systems, there isn't an easy way to update the grant tables
until MySQL 4.0.15. From version 4.0.15 on, MySQL distributions include a
`mysql_fix_privilege_tables.sql' SQL script that you can run using
the mysql client. If your MySQL installation is located at
`C:\mysql', the commands look like this:
C:\> C:\mysql\bin\mysql -u root -p mysql mysql> SOURCE C:\mysql\scripts\mysql_fix_privilege_tables.sql
If your installation is located in some other directory, adjust the pathnames appropriately.
The mysql command will prompt you for the root password; enter it
when prompted.
As with the Unix procedure, you might see some Duplicate column name
warnings as mysql processes the statements in the
`mysql_fix_privilege_tables.sql' script; you can ignore them.
After running the script, stop the server and restart it.
If you are upgrading to MySQL 5.0.1 or later, the grant table upgrade
procedure just described will add view-related columns for the
CREATE VIEW and SHOW VIEW privileges. These privileges
exist at the global and database levels. Their initial values are assigned
as follows:
mysql_fix_privilege_tables
copies the Create_priv value in the user table to the
Create_view_priv and Show_view_priv columns.
GRANT to give them to accounts
that should have them. To deal with this, first connect to the server as
root and issue the following statements to give the privileges to
the root accounts manually with UPDATE:
mysql> UPDATE mysql.user SET Show_view_priv = 'Y', Create_view_priv = 'Y'
-> WHERE User = 'root';
mysql> FLUSH PRIVILEGES;
After this, root can use GRANT to give the view privileges
to other accounts. Note: You should issue the statements just shown,
GRANT ALL will not work at the global and database levels, because
GRANT ALL requires that you actually possess all privileges.
If you are using MySQL 3.23 or later, you can copy the `.frm',
`.MYI', and `.MYD' files for MyISAM tables between different
architectures that support the same floating-point format. (MySQL takes care
of any byte-swapping issues.)
See section 14.1 The MyISAM Storage Engine.
The MySQL ISAM data and index files (`.ISD' and `*.ISM',
respectively) are architecture dependent and in some cases operating
system dependent. If you want to move your applications to another
machine that has a different architecture or operating system than your
current machine, you should not try to move a database by simply copying
the files to the other machine. Use mysqldump instead.
By default, mysqldump will create a file containing SQL statements.
You can then transfer the file to the other machine and feed it as input
to the mysql client.
Try mysqldump --help to see what options are available.
If you are moving the data to a newer version of MySQL, you should use
mysqldump --opt to take advantage of any optimizations that result
in a dump file that is smaller and can be processed faster.
The easiest (although not the fastest) way to move a database between two machines is to run the following commands on the machine on which the database is located:
shell> mysqladmin -h 'other_hostname' create db_name shell> mysqldump --opt db_name | mysql -h 'other_hostname' db_name
If you want to copy a database from a remote machine over a slow network, you can use:
shell> mysqladmin create db_name shell> mysqldump -h 'other_hostname' --opt --compress db_name | mysql db_name
You can also store the result in a file, then transfer the file to the target machine and load the file into the database there. For example, you can dump a database to a file on the source machine like this:
shell> mysqldump --quick db_name | gzip > db_name.contents.gz
(The file created in this example is compressed.) Transfer the file containing the database contents to the target machine and run these commands there:
shell> mysqladmin create db_name shell> gunzip < db_name.contents.gz | mysql db_name
You can also use mysqldump and mysqlimport to transfer
the database.
For big tables, this is much faster than simply using mysqldump.
In the following commands, DUMPDIR represents the full pathname
of the directory you use to store the output from mysqldump.
First, create the directory for the output files and dump the database:
shell> mkdir DUMPDIR shell> mysqldump --tab=DUMPDIR db_name
Then transfer the files in the DUMPDIR directory to some corresponding
directory on the target machine and load the files into MySQL
there:
shell> mysqladmin create db_name # create database shell> cat DUMPDIR/*.sql | mysql db_name # create tables in database shell> mysqlimport db_name DUMPDIR/*.txt # load data into tables
Also, don't forget to copy the mysql database because that is
where the user, db, and host grant tables are stored.
You might have to run commands as the MySQL root user on the new
machine until you have the mysql database in place.
After you import the mysql database on the new machine, execute
mysqladmin flush-privileges so that the server reloads the grant table
information.
This section describes what you should do if you are downgrading to an older MySQL version in the unlikely case that the previous version worked better than the new one.
If you are downgrading within the same release series (for example, from 4.0.20 to 4.0.19) the general rule is that you just have to install the new binaries on top of the old ones. There is no need to do anything with the databases. As always, however, it's always a good idea to make a backup.
The following items form a checklist of things you should do whenever you perform an downgrade:
You can always move the MySQL format files and data files between different versions on the same architecture as long as you stay within versions for the same release series of MySQL. The current production release series is 4.1.
If you downgrade from one release series to another, there may be
incompatibilities in table storage formats. In this case, you can use
mysqldump to dump your tables before dowgnrading. After
downgrading, reload the dump file using mysql or mysqlimport
to re-create your tables. See section 2.10.8 Copying MySQL Databases to Another Machine for examples.
The normal symptom of a downward-incompatible table format change when you downgrade is that you can't open tables. In that case, use the following procedure:
mysqldump to create a dump file.
The table format in 4.1 changed to include more and new character set
information. Because of this, you must use mysqldump to dump any tables
you have created with the newer MySQL server. For example, if all the tables
in a particular database need to be dumped to be reverted back to MySQL 4.0
format, use this command:
shell> mysqldump --create-options --compatible=mysql40 db_name > dump_file
Then stop the newer server, restart the older server, and read in the dump file:
shell> mysql db_name < dump_file
In the special case that you're downgrading MyISAM tables, no special
treatment is necessary if all columns in the tables contain only numeric
columns or string columns (CHAR, VARCHAR, TEXT, and so
forth) that contain only latin1 data. Your
4.1 tables should be directly usable with a 4.0 server.
If you used the mysql_fix_privilege_tables script to upgrade the
grant tables, you can either use the preceding method to convert them to back to
MySQL 4.0 or do the following in MySQL 4.1 (or above):
ALTER TABLE mysql.user CONVERT TO CHARACTER SET latin1 COLLATE latin1_swedish_ci; ALTER TABLE mysql.db CONVERT TO CHARACTER SET latin1 COLLATE latin1_swedish_ci; ALTER TABLE mysql.host CONVERT TO CHARACTER SET latin1 COLLATE latin1_swedish_ci; ALTER TABLE mysql.tables_priv CONVERT TO CHARACTER SET latin1 COLLATE latin1_swedish_ci; ALTER TABLE mysql.columns_priv CONVERT TO CHARACTER SET latin1 COLLATE latin1_swedish_ci; ALTER TABLE mysql.func CONVERT TO CHARACTER SET latin1 COLLATE latin1_swedish_ci;
This section discusses issues that have been found to occur on Linux. The first few subsections describe general operating system-related issues, problems that can occur when using binary or source distributions, and post-installation issues. The remaining subsections discuss problems that occur with Linux on specific platforms.
Note that most of these problems occur on older versions of Linux. If you are running a recent version, you likely will see none of them.
MySQL needs at least Linux Version 2.0.
Warning: We have seen some strange problems with Linux 2.2.14 and MySQL on SMP systems. We also have reports from some MySQL users that they have encountered serious stability problems using MySQL with kernel 2.2.14. If you are using this kernel, you should upgrade to 2.2.19 (or newer) or to a 2.4 kernel. If you have a multiple-CPU box, then you should seriously consider using 2.4 because it will give you a significant speed boost. Your system also will be more stable.
When using LinuxThreads, you will see a minimum of three mysqld processes
running. These are in fact threads. There will be one thread for the
LinuxThreads manager, one thread to handle connections, and one thread
to handle alarms and signals.
The Linux-Intel binary and RPM releases of MySQL are configured for the highest possible speed. We are always trying to use the fastest stable compiler available.
The binary release is linked with -static, which means you do not
normally need to worry about which version of the system libraries you
have. You need not install LinuxThreads, either. A program linked with
-static is slightly larger than a dynamically linked program,
but also slightly faster (3-5%). However, one problem with a statically
linked program is that you can't use user-defined functions (UDFs).
If you are going to write or use UDFs (this is something for C or C++
programmers only), you must compile MySQL yourself using dynamic linking.
A known issue with binary distributions is that on older Linux
systems that use libc (such as Red Hat 4.x or Slackware), you will get
some non-fatal problems with hostname resolution. If your system uses
libc rather than glibc2,
you probably will encounter some difficulties with hostname resolution and
getpwnam(). This happens because glibc
unfortunately depends on some external libraries to implement hostname
resolution and getpwent(), even when compiled with -static.
These problems manifest themselves in two ways:
mysql_install_db:
Sorry, the host 'xxxx' could not be looked upYou can deal with this by executing
mysql_install_db --force, which will not execute the
resolveip test in mysql_install_db. The downside is that
you can't use hostnames in the grant tables: Except for localhost,
you must use IP numbers instead. If you are using an old version of MySQL
that doesn't support --force, you must manually remove the
resolveip test in mysql_install using an editor.
mysqld with the --user
option:
getpwnam: No such file or directoryTo work around this, start
mysqld by using
the su command rather than by specifying the --user
option. This causes the system itself to change the user ID of the
mysqld process so that mysqld need not do so.
Another solution, which solves both problems, is to not use a binary
distribution. Get a MySQL source distribution (in RPM or tar.gz
format) and install that instead.
On some Linux 2.2 versions, you may get the error Resource
temporarily unavailable when clients make a lot of new connections to
a mysqld server over TCP/IP. The problem is that Linux has a
delay between the time that you close a TCP/IP socket and the time that
the system actually frees it. There is room for only a finite number
of TCP/IP slots, so you will encounter the resource-unavailable error if
clients attempt too many new TCP/IP connections during a short time. For
example, you may see the error when you run the MySQL `test-connect'
benchmark over TCP/IP.
We have inquired about this problem a few times on different Linux mailing lists but have never been able to find a suitable resolution. The only known ``fix'' is for the clients to use persistent connections, or, if you are running the database server and clients on the same machine, to use Unix socket file connections rather than TCP/IP connections.
The following notes regarding glibc apply only to the situation
when you build MySQL
yourself. If you are running Linux on an x86 machine, in most cases it is
much better for you to just use our binary. We link our binaries against
the best patched version of glibc we can come up with and with the
best compiler options, in an attempt to make it suitable for a high-load
server. For a typical user, even for setups with a lot of concurrent
connections or tables exceeding the 2GB limit, our binary is
the best choice in most cases. After reading the following text, if you
are in doubt about what to do, try our binary first to see whether it meets
your needs. If you discover that it is not good enough, then
you may want to try your own build. In that case, we would appreciate
a note about it so that we can build a better binary next time.
MySQL uses LinuxThreads on Linux. If you are using an old
Linux version that doesn't have glibc2, you must install
LinuxThreads before trying to compile MySQL. You can get
LinuxThreads at http://dev.mysql.com/downloads/os-linux.html.
Note that glibc versions before and including Version 2.1.1 have
a fatal bug in pthread_mutex_timedwait() handling, which is used
when you issue INSERT DELAYED statements. We recommend that you not use
INSERT DELAYED before upgrading glibc.
Note that Linux kernel and the LinuxThread library can by default only have 1,024 threads. If you plan to have more than 1,000 concurrent connections, you will need to make some changes to LinuxThreads:
PTHREAD_THREADS_MAX in
`sysdeps/unix/sysv/linux/bits/local_lim.h' to 4096 and decrease
STACK_SIZE in `linuxthreads/internals.h' to 256KB. The
paths are relative to the root of glibc. (Note that MySQL will
not be stable with around 600-1000 connections if STACK_SIZE
is the default of 2MB.)
The page http://www.volano.com/linuxnotes.html contains additional information about circumventing thread limits in LinuxThreads.
There is another issue that greatly hurts MySQL performance, especially on
SMP systems. The mutex implementation in LinuxThreads in glibc
2.1 is very bad for programs with many threads that hold the mutex
only for a short time. This produces a paradoxical result: If you link
MySQL against an unmodified LinuxThreads, removing processors from an
SMP actually improves MySQL performance in many cases. We have made a
patch available for glibc 2.1.3 to correct this behavior
(http://www.mysql.com/Downloads/Linux/linuxthreads-2.1-patch).
With glibc 2.2.2,
MySQL 3.23.36 will use the adaptive mutex, which is much
better than even the patched one in glibc 2.1.3. Be warned, however,
that under some conditions, the current mutex code in glibc 2.2.2
overspins, which hurts MySQL performance. The likelihood that this condition
will occur can be reduced by renicing the mysqld process to the highest
priority. We have also been able to correct the overspin behavior with
a patch, available at
http://www.mysql.com/Downloads/Linux/linuxthreads-2.2.2.patch.
It combines the correction of overspin, maximum number of
threads, and stack spacing all in one. You will need to apply it in the
linuxthreads directory with
patch -p0 </tmp/linuxthreads-2.2.2.patch.
We hope it will be included in
some form in future releases of glibc 2.2. In any case, if
you link against glibc 2.2.2, you still need to correct
STACK_SIZE and PTHREAD_THREADS_MAX. We hope that the defaults
will be corrected to some more acceptable values for high-load
MySQL setup in the future, so that the commands needed to produce
your own build can be reduced to ./configure; make; make install.
We recommend that you use these patches to build a special static
version of libpthread.a and use it only for statically linking
against MySQL. We know that the patches are safe for MySQL
and significantly improve its performance, but we cannot say anything
about other applications. If you link other applications that require
LinuxThreads against the
patched static version of the library, or build a patched shared version and
install it on your system, you do so at your own risk.
If you experience any strange problems during the installation of MySQL, or with some common utilities hanging, it is very likely that they are either library or compiler related. If this is the case, using our binary will resolve them.
If you link your own MySQL client programs, you may see the following error at runtime:
ld.so.1: fatal: libmysqlclient.so.#: open failed: No such file or directory
This problem can be avoided by one of the following methods:
-Wl,r/full/path/to/libmysqlclient.so
flag rather than with -Lpath).
libmysqclient.so to `/usr/lib'.
LD_RUN_PATH environment variable before running your client.
If you are using the Fujitsu compiler (fcc/FCC), you will have
some problems compiling MySQL because the Linux header files are very
gcc oriented.
The following configure line should work with fcc/FCC:
CC=fcc CFLAGS="-O -K fast -K lib -K omitfp -Kpreex -D_GNU_SOURCE \
-DCONST=const -DNO_STRTOLL_PROTO" \
CXX=FCC CXXFLAGS="-O -K fast -K lib \
-K omitfp -K preex --no_exceptions --no_rtti -D_GNU_SOURCE \
-DCONST=const -Dalloca=__builtin_alloca -DNO_STRTOLL_PROTO \
'-D_EXTERN_INLINE=static __inline'" \
./configure \
--prefix=/usr/local/mysql --enable-assembler \
--with-mysqld-ldflags=-all-static --disable-shared \
--with-low-memory
mysql.server can be found in the `support-files' directory under
the MySQL installation directory or in a MySQL source tree. You can install
it as `/etc/init.d/mysql' for automatic MySQL startup and shutdown.
See section 2.9.2.2 Starting and Stopping MySQL Automatically.
If MySQL can't open enough files or connections, it may be that you haven't configured Linux to handle enough files.
In Linux 2.2 and onward, you can check the number of allocated file handles as follows:
shell> cat /proc/sys/fs/file-max shell> cat /proc/sys/fs/dquot-max shell> cat /proc/sys/fs/super-max
If you have more than 16MB of memory, you should add something like the following to your init scripts (for example, `/etc/init.d/boot.local' on SuSE Linux):
echo 65536 > /proc/sys/fs/file-max echo 8192 > /proc/sys/fs/dquot-max echo 1024 > /proc/sys/fs/super-max
You can also run the echo commands from the command line as root,
but these settings will be lost the next time your computer restarts.
Alternatively, you can set these parameters on startup by using the
sysctl tool, which is used by many Linux distributions (SuSE has
added it as well, beginning with SuSE Linux 8.0). Just put the following
values into a file named `/etc/sysctl.conf':
# Increase some values for MySQL fs.file-max = 65536 fs.dquot-max = 8192 fs.super-max = 1024
You should also add the following to `/etc/my.cnf':
[mysqld_safe] open-files-limit=8192
This should allow the server a limit of 8,192 for the combined number of connections and open files.
The STACK_SIZE constant in LinuxThreads controls the spacing of thread
stacks in the address space. It needs to be large enough so that there will
be plenty of room for each individual thread stack, but small enough
to keep the stack of some threads from running into the global mysqld
data. Unfortunately, as we have experimentally discovered, the Linux
implementation of mmap() will successfully unmap a mapped
region if you ask it to map out an address currently in use, zeroing out the data
on the entire page instead of returning an error. So, the safety of
mysqld or any other threaded application depends on ``gentlemanly''
behavior of the code that creates threads. The user must take measures to
make sure that the number of running threads at any time is sufficiently low for
thread stacks to stay away from the global heap. With mysqld, you
should enforce this behavior by setting a reasonable value for
the max_connections variable.
If you build MySQL yourself, you can patch LinuxThreads for better stack use.
See section 2.12.1.3 Linux Source Distribution Notes.
If you do not want to patch
LinuxThreads, you should set max_connections to a value no higher
than 500. It should be even less if you have a large key buffer, large
heap tables, or some other things that make mysqld allocate a lot
of memory, or if you are running a 2.2 kernel with a 2GB patch. If you are
using our binary or RPM version 3.23.25 or later, you can safely set
max_connections at 1500, assuming no large key buffer or heap tables
with lots of data. The more you reduce STACK_SIZE in LinuxThreads
the more threads you can safely create. We recommend values between
128KB and 256KB.
If you use a lot of concurrent connections, you may suffer from a ``feature'' in the 2.2 kernel that attempts to prevent fork bomb attacks by penalizing a process for forking or cloning a child. This causes MySQL not to scale well as you increase the number of concurrent clients. On single-CPU systems, we have seen this manifested as very slow thread creation: It may take a long time to connect to MySQL (as long as one minute), and it may take just as long to shut it down. On multiple-CPU systems, we have observed a gradual drop in query speed as the number of clients increases. In the process of trying to find a solution, we have received a kernel patch from one of our users who claimed it made a lot of difference for his site. The patch is available at http://www.mysql.com/Downloads/Patches/linux-fork.patch. We have done rather extensive testing of this patch on both development and production systems. It has significantly improved MySQL performance without causing any problems and we recommend it to our users who still run high-load servers on 2.2 kernels.
This issue has been fixed in the 2.4 kernel, so if you are not satisfied with the current performance of your system, rather than patching your 2.2 kernel, it might be easier to upgrade to 2.4. On SMP systems, upgrading also will give you a nice SMP boost in addition to fixing the fairness bug.
We have tested MySQL on the 2.4 kernel on a two-CPU machine and found MySQL scales much better. There was virtually no slowdown on query throughput all the way up to 1,000 clients, and the MySQL scaling factor (computed as the ratio of maximum throughput to the throughput for one client) was 180%. We have observed similar results on a four-CPU system: Virtually no slowdown as the number of clients was increased up to 1,000, and a 300% scaling factor. Based on these results, for a high-load SMP server using a 2.2 kernel, we definitely recommend upgrading to the 2.4 kernel at this point.
We have discovered that it is essential to run the mysqld process
with the highest possible priority on the 2.4 kernel to achieve maximum
performance. This can be done by adding a renice -20 $$ command
to mysqld_safe. In our testing on a four-CPU machine, increasing
the priority resulted in a 60% throughput increase with 400 clients.
We are currently also trying to collect more information on how well MySQL performs with a 2.4 kernel on four-way and eight-way systems. If you have access such a system and have done some benchmarks, please send an email message to benchmarks@mysql.com with the results. We will review them for inclusion in the manual.
If you see a dead mysqld server process with ps, this usually
means that you have found a bug in MySQL or you have a corrupted
table. See section A.4.2 What to Do If MySQL Keeps Crashing.
To get a core dump on Linux if mysqld dies with a SIGSEGV signal,
you can start mysqld with the --core-file option. Note
that you also probably need to raise the core file size by adding
ulimit -c 1000000 to mysqld_safe or starting
mysqld_safe with --core-file-size=1000000.
See section 5.1.3 The mysqld_safe Server Startup Script.
MySQL requires libc Version 5.4.12 or newer. It's known to
work with libc 5.4.46. glibc Version 2.0.6 and later should
also work. There have been some problems with the glibc RPMs from
Red Hat, so if you have problems, check whether there are any updates.
The glibc 2.0.7-19 and 2.0.7-29 RPMs are known to work.
If you are using Red Hat 8.0 or a new glibc 2.2.x library, you may see
mysqld die in gethostbyaddr(). This happens because the new
glibc library requires a stack size greater than 128KB for this call.
To fix the problem, start mysqld with the --thread-stack=192K
option. (Use -O thread_stack=192K before MySQL 4.)
This stack size is the default on MySQL 4.0.10 and above, so you should
not see the problem.
If you are using gcc 3.0 and above to compile MySQL, you must install
the libstdc++v3 library before compiling MySQL; if you don't do
this, you will get an error about a missing __cxa_pure_virtual
symbol during linking.
On some older Linux distributions, configure may produce an error
like this:
Syntax error in sched.h. Change _P to __P in the /usr/include/sched.h file. See the Installation chapter in the Reference Manual.
Just do what the error message says. Add an extra underscore to the
_P macro name that has only one underscore, then try again.
You may get some warnings when compiling. Those shown here can be ignored:
mysqld.cc -o objs-thread/mysqld.o mysqld.cc: In function `void init_signals()': mysqld.cc:315: warning: assignment of negative value `-1' to `long unsigned int' mysqld.cc: In function `void * signal_hand(void *)': mysqld.cc:346: warning: assignment of negative value `-1' to `long unsigned int'
If mysqld always dumps core when it starts, the problem may be that
you have an old `/lib/libc.a'. Try renaming it, then remove
`sql/mysqld' and do a new make install and try again. This
problem has been reported on some Slackware installations.
If you get the following error when linking mysqld,
it means that your `libg++.a' is not installed correctly:
/usr/lib/libc.a(putc.o): In function `_IO_putc': putc.o(.text+0x0): multiple definition of `_IO_putc'
You can avoid using `libg++.a' by running configure like this:
shell> CXX=gcc ./configure
If mysqld crashes immediately and you are running Red Hat Version 5.0
with a version of glibc older than 2.0.7-5, you should make sure that
you have installed all glibc patches. There is a lot of information
about this in the MySQL mail archives, available online at
http://lists.mysql.com/.
In some implementations, readdir_r() is broken. The symptom is
that the SHOW DATABASES statement always returns an empty set.
This can be fixed by removing HAVE_READDIR_R from `config.h'
after configuring and before compiling.
MySQL 3.23.12 is the first MySQL version that is tested on Linux-Alpha. If you plan to use MySQL on Linux-Alpha, you should ensure that you have this version or newer.
We have tested MySQL on Alpha with our benchmarks and test suite, and it appears to work nicely.
We currently build the MySQL binary packages on SuSE Linux 7.0 for AXP, kernel 2.4.4-SMP, Compaq C compiler (V6.2-505) and Compaq C++ compiler (V6.3-006) on a Compaq DS20 machine with an Alpha EV6 processor.
You can find the preceding compilers at
http://www.support.compaq.com/alpha-tools/. By using these compilers
rather than gcc, we get about 9-14% better MySQL performance.
Note that until MySQL version 3.23.52 and 4.0.2, we optimized the binary for
the current CPU only (by using the -fast compile option). This means
that for older versions, you can use our Alpha binaries only if you have an
Alpha EV6 processor.
For all following releases, we added the -arch generic flag
to our compile options, which makes sure that the binary runs on all Alpha
processors. We also compile statically to avoid library problems.
The configure command looks like this:
CC=ccc CFLAGS="-fast -arch generic" CXX=cxx \
CXXFLAGS="-fast -arch generic -noexceptions -nortti" \
./configure --prefix=/usr/local/mysql --disable-shared \
--with-extra-charsets=complex --enable-thread-safe-client \
--with-mysqld-ldflags=-non_shared --with-client-ldflags=-non_shared
If you want to use egcs, the following configure line worked
for us:
CFLAGS="-O3 -fomit-frame-pointer" CXX=gcc \
CXXFLAGS="-O3 -fomit-frame-pointer -felide-constructors \
-fno-exceptions -fno-rtti" \
./configure --prefix=/usr/local/mysql --disable-shared
Some known problems when running MySQL on Linux-Alpha:
gdb 4.18. You should use gdb 5.1 instead.
mysqld statically when using gcc, the
resulting image will