This is the MySQL reference manual. This version documents the 3.21.18a-beta version of MySQL.
MySQL is a basically free SQL database server. See section 3 Licensing or When do I have/want to pay for MySQL?.
The latest information about MySQL is found at the MySQL Home page
To see what it can do. See section 1.4 The main features of MySQL.
For installation instructions See section 4 Compiling and installing MySQL. For tips on how to port MySQL to new machines/operating systems See section F Comments on porting to other systems..
If you have any suggestions concerning additions or corrections to this manual, please send them to the MySQL mailing list Here]}. See section 2.1 Subscribing to/un-subscribing from the MySQL mailing list..
See section 8.5.1 Upgrading to 3.21 from a 3.20 version, for information about upgrading from a 3.20 release.
For examples of SQL and benchmarking information see the `bench' directory.
For future plans See section E List of thing we want to add to MySQL in the future..
A history of new features/bug fixes See section C MySQL change history.
For the currently known bugs/misfeatures (known errors) See section D Known errors and design deficiencies in MySQL.
For A list of all the contributors to this product See section B Who has helped to make MySQL..
IMPORTANT:
Send bug (error) reports, questions and comments to the mailing list at
Please use the mysqlbug script when posting bug reports or
questions about MySQL. mysqlbug will gather some
information about your system and start your editor with a form in which
you can describe your problem. Bug reports might be silently ignored by
the MySQL maintainers if there is not a good reason included in
the report as to why mysqlbug has not been used. A report that says
'MySQL does not work for me. Why?' is not consider a valid bug report.
The mysqlbug script can be found in the `scripts' directory in the distribution, that is `there-you-installed-mysql/scripts'.
This manual is currently available in TeXInfo, Raw text, Info, PostScript and HTML versions.
The primary document is the TeXInfo file. The HTML version is
automatically produced with a modified texi2html. The ASCII and
info version are produced with makeinfo. The Postscript version
is produced using texi2dvi and dvips.
This manual was written and is maintained by David Axmark, Michael (Monty) Widenius and Kim Aldale. The DBI chapter was original written by Jay Flaherty.
MySQL is a SQL (Structured Query Language) database server.
SQL is the most popular database language in the world. MySQL
is a client server implementation that consists of a server daemon
mysqld and many different client programs/libraries.
The main goals of MySQL are speed and robustness.
The base upon which MySQL is built is a set of routines that have been used in a highly demanding production environment for many years. While MySQL is still in development it already offers a rich and highly useful function set.
The official way to pronounce MySQL is 'My Ess Que Ell' (Not MY-SEQUAL).
We once started off with the intention to use mSQL to connect to
our own fast low level (ISAM) tables. However, after some testing we
came to the conclusion that mSQL was not fast 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 chosen
to ease porting of third party code.
It is not perfectly clear where the name MySQL derives from. Our base directory and a large amount of our libraries and tools have had the prefix 'my' for well over 10 years. However, Monty's daughter (some years younger) is also named My. So which of the two gave its name to MySQL is still a mystery, even for us.
FLOAT, DOUBLE, CHAR, VARCHAR,
TEXT, BLOB, DATE, SET and ENUM
types. See section 7.2 Column types.
select column1 + column2 from table where column1/column2 > 0
GROUP BY and ORDER BY. Support for
group functions (COUNT, AVG, SUM, MAX and
MIN).
LEFT OUTER JOIN with ANSI SQL and ODBC syntax.
DELETE, INSERT, REPLACE, and UPDATE returns
how many rows were affected.
--help or -? for help.
show tables, show index from table and
show columns from table
There is one SQL tutor on the net.
This book has been recommended by a lot of people on the MySQL mailing list.
Judith S. Bowman, Sandra L. Emerson and Marcy Darnovsky "The Practical SQL Handbook: Using Structured Query Language" Second Edition Addison Wesley ISBN 0-201-62623-3 http://www.awl.com
And another book also recommended by people on the MySQL mailing list.
Understanding SQL ISBN 0-89588-644-8 Publisher Sybex 510 523 8233 Alameda CA USA
There are also a lot of web pages that uses MySQL. See section A Some users of MySQL..
A stored procedure is some code that is stored and run in the server. After this the client doesn't have to issue the whole query but can refer to the stored procedure. This gives more speed because the query only has to be parsed once and less data has to be sent between the server and the client. You can also raise the conceptual level by having libraries of functions in the server.
A trigger is a stored procedure that is invoked when something happens. For example one can install a stored procedure that checks every delete to a transaction table and does a automatic delete on the corresponding customer when all his transactions are deleted.
To se when MySQL migth get theese function set the todo. See section E List of thing we want to add to MySQL in the future..
Requests to be added or dropped from the MySQL list should be
sent to the electronic mail address mdomo@tcx.se. Sending a one
line message saying either subscribe mysql or unsubscribe
mysql will suffice. If your reply address is not valid you may use
subscribe mysql your@address.your-domain or unsubscribe
mysql your@address.your-domain.
Please do not send mail about [un]subscribing to automatically forwarded to hundreds of other users.
Your local site may have many subscribers to MySQL. In that
case, it may have a local mailing list, so that a single message from
tcx.se is sent to the site and propagated to the local list. In
such cases, please contact your system administrator to be added to or
dropped from the local MySQL list.
Mail to mdomo is handled automatically by majordomo.
Before you ask a question on the mailing list it is a good idea to check this manual. If you can't find an answer here, check with your local MySQL expert. If you still can't find an answer to your question go ahead and read the next section about how to send mail to
If you can, please use the `mysqlbug' script that can be found in the scripts directory in the distribution. If that is not possible, remember to specify (if relevant) the following. Note that it is possible to answer a letter with to much information but not one with to little.
mysqladmin version.
uname -a.
If you are a support customer, please post the bug report to the specified mailing list for higher priority treatment.
When answers are sent to you individually and not to the mailing list, it is considered good etiquette to summarise the answers and mail them to the mailing list.
Since it is very hard to now why something crashing please do one of the following things.
First try to check if thigs that work for other crash for you:
--with-debug switch to
configure. This will include a safe memory allocator that can find some
errors. This also gives a lot of output about what is happening.
back (or the backtrace command in your debugger) when
mysqld core dumps.
Try to make your answer broad enough that people other than the original poster may benefit from it. 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. In such cases, please make sure that your answer is not a duplication of a previous answer.
Try to summarise the essential part of the question in your reply, but don't feel obliged to quote the whole question.
Basic licensing issues:
See section I The MySQL server license.
For normal use MySQL costs nothing. When you sell MySQL directly or as a part of another product you have to pay for it. See section I The MySQL server license.
The client access part of MySQL is in the public domain. The command line client includes parts that is under the GNU Public License (readline).
These are our current license prices. All prices in US Dollars. If you pay by credit card the currency is FIM (Finish Marks) so the prices will differ slightly.
| Number of licenses | Price/Copy | Total |
| 1 | US $200 | US $200 |
| 10 pack | US $150 | US $1500 |
| 50 pack | US $120 | US $6000 |
| licenses | Price/Copy | Minimum at one time | Minimum Payment |
| 100-1000 | $40 | 100 | $4000 |
| 1000-2500 | $25 | 200 | $5000 |
| 2500-5000 | $20 | 400 | $8000 |
A full price license includes really basic support. This means that we are trying to answer any relevant question. If the answer is in the documentation, we are going to direct you to the relevant documentation. If you do not have a license/support we will probably not answer at all.
If you discover what we consider a real bug, we are likely to fix it in any case. But if you pay for support we will notify you about the fix status instead of just fixing it in a later release.
More comprehensive support is sold separately:
One year of basic email support costs $200 (USD).
It includes:
One year of extended email support costs $1000 (USD).
Extended basic supports contains everything in basic email support with these additions:
BLOB or TEXT types
yet). The current server includes support to read such databases but not
the packing tool.
One year of email/phone/telnet support costs $2000 (USD).
Login supports contains everything in extended basic email support with these additions:
One year of extended email/phone/telnet support costs $5000 (USD).
Extended login supports contains everything in login support with these additions:
select my_calculation(column1,column2) from database;
Currently we can take SWIFT payments, cheques or credit cards.
Payment should be made to:
Postgirot Bank AB 105 06 STOCKHOLM, SWEDEN T.C.X DataKonsult AB BOX 6434 11382 STOCKHOLM, SWEDEN SWIFT address: PGSI SESS Account number: 96 77 06 - 3 Specify: license and/or support and your name and email address.
In Europe and Japan you can use EuroGiro (that should be cheaper) to the same account.
If you want to pay by cheque make it payable to "Monty Program KB". And mail it to the address below.
Monty Program KB Michael Widenius Gamla Skomakarbolev. 1 E 11 00740 Helsingfors Finland
If you want to pay with credit card over the Internet you can use TcX's secure license form
For commercial licensing, or if you have any questions about any of the information in this section, please contact:
David Axmark Detron HB Kungsgatan 65 B 753 21 UPPSALA SWEDEN Voice Phone +46-18-10 22 80 (Swedish and English spoken) Fax +46-8-729 69 05 (Email *much* preferred) E-Mail: mysql-licensing@tcx.se
There are (at least) four different copyrights on the MySQL distribution.
mysqlclient
library and programs in the `client' directory is in the public
domain. Each file which is in the public domain has a header which clearly
states so. This is everything in `client' directory and some parts of
mysys, mystring and dbug libraries.
Our philosophy behind this is:
This is a clarification of the information in the 'MySQL FREE PUBLIC LICENSE'. See section I The MySQL server license.
MySQL may be used freely, including by commercial entities for evaluation or unsupported internal use. However, distribution for commercial purposes of MySQL, or anything containing or derived from MySQL in whole or in part, requires a written commercial license from TcX AB, the sole entity authorised by to grant such licenses.
You may not include MySQL "free" in a package containing anything for which a charge is being made except as noted below.
The intent of the exception provided in the second clause is to allow commercial organisations operating an FTP server or a bulletin board to distribute MySQL freely from it, provided that:
If you want to distribute software in a commercial context that incorporates MySQL and you do not want to meet these conditions, you should contact TcX AB to find out about commercial licensing. Commercial licenses involve a payment, and include support and other benefits. These are the only ways you legally can distribute MySQL or anything containing MySQL: either by distributing MySQL under the requirements of the FPL, or by getting a commercial license from TcX AB.
I want to sell a product that can be configured to use MySQL although my customer is responsible for obtaining/installing MySQL (or some other supported alternative). Does one of us owe you money if my customer chooses to use MySQL?
If your product REQUIRED MySQL to work you would have to pay a license. If MySQL just added some new features it should fall inside normal use. For example, if using MySQL added logging to a database instead of a text file it would not require a license. This would, of course, mean that the user has to fetch and install MySQL by himself. If the program is (almost) useless without MySQL you would have to get a MySQL license to sell your product.
Do I have to get a license for my copy?
No you are not selling MySQL itself. But is this case we would like you to purchase MySQL support. That is either your support of MySQL or our support of you (the later is more expensive since our time is limited).
Is your script designed for MySQL alone? Does it require MySQL to function at all? Or is it designed for `a database' and can run under MySQL, PostgreSQL, or something else?
If you've designed it strictly around MySQL then you've really made a commercial product that requires the engine, so yes, I would think you have to pay.
If, however, you can support any database with a base level of functionality (and you don't rely on anything that only MySQL supports) you probably DO NOT have to pay.
It also depends on what you're doing for the client. Are you tying into a database you expect to already exist by the time your software is purchased? Then you again probably don't have to pay. Or do you plan to distribute MySQL or give them detailed instructions on installing it with your software? Then you probably do.
One thing I'd like to suggest, folks. Look, development won't last forever if nobody pays. I agree that buying a copy for every software user is prohibitive compared to other products available but would it not be courtesy for commercial developers to register their OWN copy that they develop with?
We may choose to distribute older versions of MySQL with the GPL in the future. However these versions will be identified as GNU MySQL. Also all copyright notices in the relevant files will be changed to the GPL.
You can always check MySQL's home page to see what the latest news.
But since the Internet connection at tcx is not to fast we would prefer if you do the actual downloading from one of the mirrors below.
Europe:
North America:
Asia:
Australia:
The first decision is if you want to use the latest development release or the last stable release.
Normally if you are starting with development we recommend going with the development release. This is because there are usually no realy bad bugs in the development release and if you can easily test it on you machine with the crash-me and benchmark tests. See section 12 MySQL benchmark suite.
The second decision is if you want a source of a binary release.
If you want to run MySQL on a platform that has a current binary release use that. A binary version of MySQL is easier to install.
If you want to read (and/or modify) the C and C++ code that makes up MySQL you should always get a source distribution. The code is always the ultimate manual. The source distribution also contains more tests and examples than the binary distribution.
To clarify our naming schema:
All MySQL versions is run trough our standard test and the benchmarks to ensure that they are relatively safe to use. The standard test is also extended the whole time to test for all previously found bugs, so it's gets better the whole time.
The MySQL release numbers consists of 3 numbers and a suffix.
So a release name like mysql-3.21.17-beta means.
Note that all releases has at least been tested with:
Another test is our internal production. We usually use the latest version for this (at least on one machine) and we have more than 100 giga byte of data to work with.
We are going to use the following policy when updating MySQL:
Each minor version will increment the last number in the version string. When there are major new features or minor incompatibilities with previous versions, the second number in the version string will be incremented. When the file format changes the first number will be increased.
We use GNU autoconf so it will be possible to port to all modern systems with working Posix threads and a C++ compiler. The client code requires C++ but not threads. We use/develop the software ourselves primarily on Sun Solaris (version 2.5 & 2.6) and some on RedHat Linux 5.0.
The following OS/thread package's has been reported to compile MySQL successfully. Note that for many OSes the native thread support only works in the latest versions.
What you need:
gzip to uncompress the distribution.
tar to unpack the distribution. GNU tar is
known to work.
C++ compiler. gcc >= 2.7, SGI C++, SunPro C++ are
some of the compilers that are known to work. libg++ is not
needed when using gcc.
make.
Unpack tar archive in a directory. The tar file should be named like mysql-VERSION.tar.gz (VERSION is a number like 3.21.18a-beta). A directory named mysql-VERSION should be created.
zcat mysql-VERSION.tar.gz | tar xvf -
cd mysql-VERSION
./configure
make
make install
./scripts/mysql_install_db
'installation_directory'/bin/mysqladmin version
mysqladmin Ver 6.3 Distrib 3.21.17, for pc-linux-gnu on i686 TCX Datakonsult AB, by Monty Server version 3.21.17-alpha Protocol version 10 Connection Localhost via UNIX socket TCP port 3306 UNIX socket /tmp/mysql.sock Uptime: 16 sec Running threads: 1 Questions: 20 Reloads: 2 Open tables: 3
Usual configure switches:
--without-server
--prefix=/usr/local or --prefix=/usr/local
--localstatedir=/usr/local/data/mysql
--with-unix-socket-path=absolute_file_name
--with-charset=charset.
Where [charset] may be one of: big5, czech, dec8,
dos, german1, hp8, koi8_ru, latin1,
latin2, swe7 or usa7.
If you want to add another character set to MySQL you must:
mysql_source_directory/strings/ctype-$CHARSET_NAME.c.
CHARSETS_AVAILABLE list in
configure.in
isamchk -r -q on every
table. Otherwise things will be sorted incorecctly in some cases (but
not all!).
GNU make is always recommended and sometimes required.
About creating the grants database `mysql_install_db':
The default priviliges is that anybody may create/use the databases
named test or starting with test_. root can do
anyting. See section 6.2 How does the privilege system work?.
To change the defaults edit the script before running it. If this is
the first time you install MySQL you must run this command. If
you don't do it you will get the error: Can't find file:
'./mysql/host.frm'. This script also starts the mysqld daemon the first
time.
Normal start of the MySQL server demon (not needed the first
time): 'installation_directory'/bin/safe_mysqld --log
Some times patches appear on the mailing-list. To apply on do something like this:
cd 'old-mysql-source-distribution-path' gunzip < patch-file-name.gz | patch -p1 rm config.cache make clean
And then follow the instructions for a normal source install from the
./configure step.
And the restart your MySQL server.
If your compile fails with something like:
configure: error: installation or configuration problem: C++ compiler cannot create executables.
Try setting the environment variable CXX to "gcc -O3" (If
you are using gcc). For example CXX="gcc -O3"
./configure. If you use this you don't nead to have libg++ installed!
You can also install libg++. By default `configure' picks
c++ as a compiler name and GNU c++ links with
-lg++.
making all in mit-pthreads make: Fatal error in reader: Makefile, line 18: Badly formed macro assignmentThis means you have to upgrade your make to GNU make.
CC="gcc -O4" CXX="gcc -O4" export CC CXX
Can't find Makefile.PL when making
mysqlperl you should try using GNUx make. At least Solaris and FreeBSD
is known to have troublesome make programs.
pthread.h: No such file or directory
This means you have to upgrade your make to GNU make (At least GNU make
version 3.75 works).
client/libmysql.c:273: parse
error before `__attribute__'
This means you need to upgrade your gcc compiler (2.7.2 is known to work).
mysqlbug
when posting questions to mysql@tcx.se. See section 2.3 I think I have found a bug. What information do you need to help me?.
Even if the problem isn't a bug, mysqlbug gathers some system
information that will help other solve your problem!
configure --with-debug=yes
Before running a client you should do:
MYSQL_DEBUG=d:t:o,/tmp/client.trace export MYSQL_DEBUGYou will now get a trace file in `/tmp/client.trace'.
mysql --debug=d:t:o,/tmp/client.trace before mailing a bug
report. See section 2.3 I think I have found a bug. What information do you need to help me?.
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);
Then configure didn't detect the type of the last argument to
accept(), getsockname() and getpeername(). Search
after the line:
/* Define as the base type of the last arg to accept */ #define SOCKET_SIZE_TYPE ###and change ### to size_t or int depending on your operating system.
All MySQL programs compile clean (no warnings) for us (on Solaris using gcc). But warning may appear because of different system include files. Se below for warnings that may occur when using mit-pthreads.
When compiling sql_yacc.yy you should probably get:
conflicts: 4 reduce/reduce
You probably have to use bison to compile sql_yacc.yy. If you get an error like:
"sql_yacc.yy", line xxx fatal: default action causes potential...
you have to install bison (the gnu yacc).
If you want to have static linked code, use (with gcc):
LDFLAGS="-static" ./configure ...
Building in a non source directory is not supported when using MIT-threads. This is because we want to keep our changes to this code minimal.
MIT-pthreads doesn't support the AF_UNIX protocol so we must use
the TCP/IP protocol for all connections (which is a little slower). If
you can't connect to a table, try using the host (-h or
--host) switch to mysql. This must be done if you have
compiled the client code --without-server because the default
connection is to use Unix sockets.
MySQL compiled with MIT threads has as default system locking
disabled for performance reasons. One can start the server with system
locking with the --use-locking.
Sometimes (at least on Solaris) the pthread bind() command fails
to bind to a socket without any error message. The result of this is
that all connections to server fails.
> mysqladmin ver 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 demon and restart it.
This has only happened to us when we have forced the demon down and done
an restart directly.
sleep() isn't interruptible with SIGINT (break) with
MIT-threads. This is only notable in mysqladmin --sleep. One have
to wait for the end of the sleep before the interrupt is served and the
process stops.
We haven't got readline to work with MIT threads. (This isn't needed, but may be interesting for someone)
When linking (at least on Solaris) you will receive warning messages like:
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
Some other warnings which also can be ignored:
implicit declaration of function `int strtoll(...)' implicit declaration of function `int strtoul(...)'
The included perl client code requires perl5.004 or later.
If you got a the following error (from mysqlperl or DBD-mysql):
/usr/bin/perl: can't resolve symbol '__moddi3' /usr/bin/perl: can't resolve symbol '__divdi3'
You are probably using gcc (or using a old binary compiled with
gcc). Add -L/usr/lib/gcc-lib/... -lgcc to the link command where
-L/... is the path to the directory where libgcc.a
exists.
Sun native threads only works on Solaris 2.5 and higher. For 2.4 and earlier versions you can use MIT-pthreads. See section 4.8 MIT-pthreads notes. (FreeBSD).
If there is too many processes that tries to connect very rapidly to the
mysqld one will get Error in accept : Protocol error in
the mysql log.
If you have the Sun Workshop 4.2 compiler you can configure with:
CC="cc -Xa -fast -xstrconst" CXX="CC -xsb -noex -fast"
./configure
You may also have to change the row in configure:
#if !defined(__STDC__) || __STDC__ != 1 to #if
!defined(__STDC__) because if you turn on __STDC__ with the
-Xc switch, the Sun compiler can't compile with the Solaris
`pthread.h' header files anymore. This is a Sun bug (Broken
compiler or broken include file).
On SunOS 4 MIT-pthreads is needed. You must have gnu make to compile (because of MIT-pthreads).
In readline you may get warnings about duplicated defines. These may be ignored.
When compiling mysqld there will be some warnings about implicit
declaration of function. These may be ignored.
On Linux you should (it is added automatically by safe_mysqld)
use the --skip-locking flag to mysqld. This is because a
bug in Linux file locking calls. This error has been verified to still
exists in Linux version 2.0.32.
When using LinuxThreads you will see a minimum of three processes running. These are in fact threads. There will be one thread for the Linux Threads manager, one thread to handle connections, and one thread to handle alarms and signals.
LinuxThreads should be installed before configuring MySQL!
MySQL libc version 5.4.12 or newer. glibc version 2.0.6 and later should also work.
On some older Linux distributions configure may give a error
about: 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 says and add a extra underscore to the _P macro that only
has one underscore. And then try again.
You will get some warnings when compiling: (these 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'
When using glibc 2 you must also execute the configure with
CXX=gcc ./configure ... because if you compile with g++, you
will link with libg++ which dosen't work with LinuxThreads.
If you want in Debian GNU/Linux to get MySQL to auto start when system boots, do the following:
> cp scripts/mysql.server /etc/init.d/mysql.server > /usr/sbin/update-rc.d mysql.server defaults 99
There is a bug in glibc 2.0.5 in how pthread_key_create variables are freed. With glibc2 2.0.5 (For example on RedHat 5.0 systems) you have to use the staticly linked MySQL binary distribution.
If mysqld always does a core dump when starting, the problem may be that you have and old `/lib/libc.a'. Try renaming this, remove sql/mysqld and do a new make install and try again. This problem has been reported on some Slackware installations.
In some implementations readdir_r is broken. This will be
notised by that SHOW DATABASES always return an empty set. This
can be fixed by removing HAVE_READDIR_R from `config.h'.
If you get problems you probably have to apply a patch to your Linux installation. The patch can be got at . This patch is against the linux distribution `sparclinux-2.0.30.tar.gz', that is available at vger.rutgers.edu. This is a version of linux which was never merged with the official 2.0.30. You also have to install linuxthreads 0.6 or newer.
Thanks to jacques@solucorp.qc.ca for the above information.
The first problem is linuxthreads. You must patch linuxthreads for alpha because the RedHat distribution uses an old (broken) linuxthread version.
Note that Alpha-Linux is still an alpha platform for MySQL. With RedHat 5.0 and the patched linuxthreads you have a very good change to get this to work.
When compiling threaded programs under Digital UNIX using CC / CXX the
documentation recommends the switch to cc and cxx and the libraries
-lmach -lexc (in addition to -lpthread).
So you have to configure with something like this:
CC="cc -pthread" CXX="cxx -pthread -O" ./configure
-with-named-thread-libs="-lpthread -lmach -lexc -lc"
When compiling mysqld you will may this warning for mysqld for a couple of lines:
mysqld.cc: In function void handle_connections()': mysqld.cc:626: passing long unsigned int *' as argument 3 of accept(int,sockad ddr *, int *)'
You can safely ignore these. This is because configure can't detect warnings, only errors.
You may get problems with the server exiting directly. If so try
starting it with nohup safe_mysqld [options]
nohup is a command that ignores any SIGHUP sent from the
terminal.
In some versions of OSF1 the alloca() functions is broken. Fix
this by remove 'HAVE_ALLOCA' from config.h.
When using the Digital C++ you could try
-with-named-thread-libs="-lpthread -lmach -lexc -lc"
You may have to undefine some things in `config.h' (generated by `./configure').
In some Irix implementations the alloca() function is broken. If
the mysqld server dies on some selects remove HAVE_ALLOC &
HAVE_ALLOCA_H from `config.h'. If mysqladmin create doesn't
work, remove HAVE_READDIR_R from config.h. Also you may have to
remove HAVE_TERM_H.
Irix 6.2 doesn't support POSIX threads out of of the box. You have install these patches, available from SGI if you have support:
1403, 1404, 1644, 1717, 1918, 2000, 2044
If you get the something like the following error when compiling mysql.cc:
"/usr/include/curses.h", line 82: error(1084): invalid combination of type
type the following in the mysql installation directory:
> extra/replace bool curses_bool < /usr/include/curses.h > include/curses.h > make
There has also been reports about scheduling problems. This is if only one thread is running things go slow. Avoid this by starting another client. This may lead to a 2-10 fold increase in execution speed hereafter for the other thread.
This is a badly understood problem with IRIS threads so you may have to improvise to find solutions until it can be fixed.
If you get link errors when compiling mysqlperl (Type
ient.a(my_getwd.o): RRS text relocation at 0x9a9f for
"__db_pargs_")
You must recompile the Perl code with -DPIC -fpic.
Do the following:
CFLAGS = -g -O2 to
CFLAGS = -O2 -DPIC -fpic
cd client
rm *.o
make libmysqlclient.a
cd ../perl/mysqlperl
make
This shall hopefully be handled automatically in the future.
The FreeBSD make behaviour is slightly different from GNU makes. If you have a problem that `mysqlperl/Makefile.PL'x doesn't get generated you should install GNU make.
Other (temporary) solution:
> cd perl > make mysqlperl/Makefile.PL > make mysqlperl/mysql_test
If you get ERROR Can't create/write to file 'xxx.ISD' error 23
from MySQL this means that you haven't allocated enough file
descriptors for MySQL. perror # will give you the error
message in a more readable form.
There is commented line ulimit -n 256 in `safe_mysqld'. You
can remove this comment and of course increase or decrease the value if
you want. You can also make the table cache smaller with:
safe_mysqld -O table_cache=32 (the default is 64).
If mysql or mysqladmin takes a long time to respond a user said the following.
Are you running the ppp user process? On my FreeBSD box (2.2.5) MySQL clients takes a couple of seconds to connect to mysqld if the ppp process is running.
You have to configure with:
--with-named-thread-libs=-lc_r
The pthreads library for FreeBSD doesn't contain the sigwait
function and there is some bugs in it. To fix this, get the
`FreeBSD-3.0-libc_r-1.0.diff' file and apply this in the
`/usr/src/lib/libc_r/uthread' directory. Follow after this the
instructions that can be found with man pthread about how to
recompile the libc_r library.
You can test if you have a 'modern' libpthread.a with:
> nm /usr/lib/libc_r.a | grep sigwait.
If the above doesn't find sigwait you have to use the above patch
and recompile libc_r.
From Jan Legenhausen jleg@csl-gmbh.net.
I finally got mysqlperl working on BSDI2.1.
What i did was almost nothing:
GCC="shlicc2" per default;
perl5 automagically uses shlicc2 - you should use _one_ version (either
gcc or shlicc2) for both Mysql.c and
libmysqlclient.a!)
rm *.o
gmake libmysqlclient.a
cd ../perl/mysqlperl
make clean
$sysliblist=" -L$tmp -lgcc -lcompat"; to Makefile.PL line 45
(just to be sure - i didn't check if one could leave out this one)
perl Makefile.PL
libmysqlclient.a's in /usr/lib and
/usr/contrib/lib
make install
If you can't run the mysql_install_db script because the script
can't connect to the server you should check that you have an entry in
/etc/hosts like:
127.0.0.1 localhost
If you get the following error when compiling MySQL:
item_func.h: In method `Item_func_ge::Item_func_ge(const Item_func_ge &)': item_func.h:28: virtual memory exhausted make[2]: *** [item_func.o] Error 1
Then your ulimit for virtual memory is too low. Try using: ulimit
-v 30000 and do make again.
env CXX=shlicc++ CC=shlicc2 ./configure --prefix=/usr/local --localstatedir=/var/mysql --without-perl --with-unix-socket-path=/var/mysql/mysql.sock
You can change the directory locations if you wish, or just use their defaults by not specifying them.
The current port is only tested on a 'sco3.2v5.0.4' system.
SCO development notes:
-lgthreads -lsocket -lgthreads
When using THE IBM compiler something like this is needed.
CC="xlc_r -ma -O3 -qstrict" CXX="xlC_r -ma -O3 -qstrict" ./configure
Automatic detection of xlC is missing from autoconf.
PLEASE always use the mysqlbug script when posting questions to the mailinglist (mysql@tcx.se). Even if the problem isn't a bug, mysqlbug gathers some system information that will help other solve your problem! See section 2.3 I think I have found a bug. What information do you need to help me?.
> cd /usr/local > zcat /<where ever you put it>/mysql-3.20.0-SunOS5.tgz | tar xvf - > ln -s mysql-VERSION mysql
> scripts/mysql_install_dbThe
mysql_install_db script also starts the mysqld demon.
> bin/safe_mysqld --log &
> bin/mysqladmin verThat should print something like this. The exact output depends on you platfrom and use.
bin/mysqladmin Ver 6.3 Distrib 3.21.15-alpha, for SOLARIS 2.5 on SPARCstation TCX Datakonsult AB, by Monty Server version 3.21.15-alpha Protocol version 9 Connection Localhost via UNIX socket TCP port 3306 UNIX socket /tmp/mysql.sock Uptime: 2 days 1 hour 42 min 3 sec Running threads: 2 Questions: 450378 Reloads: 17 Open tables: 64
> cd mysqlperl > perl Makefile.PL > make > make install
You should use the safe_mysqld script to the server.
safe_mysqld expects one of two conditions to be true:
/usr/local/mysql)
/my/. To get it to run correctly,
you should cd to /usr/local/mysql and then execute
safe_mysqld or modify the script so that it expected the base
mysql directory to be `/usr/local/mysql' rather than the default
`/my/'.
By executing
> bin/mysqld --help
you will get the options for mysqld (and safe_mysqld) and the current
paths. Normally you only should need to change the
--basedir=path. You can test the path switches by executing:
> bin/mysqld --basedir=/usr/local --help
If you would like to use mysqlaccess and have the mysql distribution in
some nonstandard place you have to change the path to mysql in
mysqlaccess. bin/mysqlaccess about line 308:
$MYSQL = '/usr/local/bin/mysql --batch --unbuffered';
If you don't change the path you will get a 'broken pipe' error when using mysqlaccess.
If you would like MySQL to start when you boot your machine,
you can copy bin/mysql.server to where your system has it startup
files. More information can be bound in the bin/mysql.server script
itself.
The binary distribution of MySQL for HP-UX is distributed as an HP depot file. This means that you must be running at least HP-UX 10.x to have access to HP's software depot tools.
This version of MySQL was compiled on an HPUX 9000/8xx server under HP-UX 10.20, and uses MIT Pthreads. It is known to work, and work well under this configuration. This version does *not* use HP's native thread package. It is highly unlikely that MySQL will use HP native threads on anything but HP-UX 10.30 or later.
Other configurations that may work:
9000/7xx - HP-UX 10.20+ 9000/8xx - HP-UX 10.30 (does not use HP native threads)
The following configurations almost definately wont work:
9000/7xx or 8xx - HP-UX 10.x where x < 2 9000/7xx or 8xx - HP-UX 9.x
To install (everything, incl server, client and devel tools):
/usr/sbin/swinstall -s <full path to the depot file> mysql.full
To install server only:
/usr/sbin/swinstall -s <full path to the depot file> mysql.server
To install client pack only:
/usr/sbin/swinstall -s <full path to the depot file> mysql.client
To install developers tools only:
/usr/sbin/swinstall -s <full path to the depot file> mysql.developer
The depot will place binaries/libraries in /opt/mysql and data in /var/opt/mysql. The depot will also create the appropriate entries in /sbin/init.d and /sbin/rc2.d to automatically start the server on boot. This would obviously entail being root to install.
Clients have to be linked with: -lmysqlclient
Check the log file to see if mysqld started up correctly.
mysqld demon starts with a cd to 'mysql-data-dir'. After this, mysqld-data-dir
is changed to './' (current dir). All paths (databases, pid file, and log file) have this
directory as base path './'. If you have any problems with wrong paths,
try mysqld --help to see your current paths. Every path can be changed by a startup
option to safe_mysqld or mysqld
cd <localstatedir default /usr/local/var> tail <your host name>.log
To verify that MySQL is working run the following tests:
> cd /usr/local/bin > ./mysqlshow +-----------+ | Databases | +-----------+ | mysql | +-----------+ > ./mysqlshow mysql Database: mysql +--------+ | Tables | +--------+ | db | | host | | user | +--------+ > ./mysql -e "select host,db,user from db" mysql +------+--------+------+ | host | db | user | +------+--------+------+ | % | test | | | % | test_% | | +------+--------+------+
There is also a benchmark suite so you can compare how MySQL perform on different platforms. In the near future this will also be used to comapre MySQL to other SQL databases.
> cd bench > run-auto-increment-test
You can also run the tests in the test subdirectory. To run `auto_increment.tst':
./mysql -vf test < ./tests/auto_increment.tst
Expected results are shown in the file `./tests/auto_increment.res'.
To start or stop MySQL use the following commands:
scripts/mysql.server stop scripts/mysql.server start
You might want to add these start and stop commands in the appropriate places in your `/etc/rc*' files when you start using MySQL for production applications.
The following are useful extensions in MySQL that you probably will not find in other SQL's. Be warned that if you use them, your code will not be portable to other SQL servers.
MEDIUMINT, SET, ENUM and the
different BLOB and TEXT types.
AUTO_INCREMENT, BINARY,
UNSIGNED and ZEROFILL.
INTO OUTFILE and STRAIGHT_JOIN in a SELECT
statement. See section 7.10 SELECT syntax.
EXPLAIN SELECT to get a description on how tables are joined.
INDEX or KEY in a CREATE TABLE
statement. See section 7.6 CREATE TABLE syntax.
DROP column or CHANGE column in a ALTER TABLE
statement. See section 7.7 ALTER TABLE syntax.
LOAD DATA INFILE. This syntax is in many cases compatible with
Oracles LOAD DATA INFILE. See section 7.14 LOAD DATA INFILE syntax.
" instead of ' to enclose strings.
\ character.
SET OPTION statement. See section 7.20 SET OPTION syntax.
SELECT part of a GROUP BY statement, fields
or functions that do not appear in the GROUP BY list. In
MySQL this means 'any matching value'. By using this one can
get a much higher performance by avoiding sorting and grouping
unnecessary items. This is often used in this context:
SELECT order.custid,customer.name,max(payments) from order,customer WHERE order.custid = customer.custid GROUP BY order.custid;In ANSI SQL you would have to add the customer.name in the
GROUP BY
clause which is redundant in MySQL.
|| and && operators is in MySQL synonyms for
OR and AND, like in the C programming language. Likewise
| and & stands for bitwise OR and AND.
Because if this nice syntax, MySQL doesn't support the ANSI SQL
operator || for string concatenation, and one has to use
CONCAT() instead. As CONCAT() takes any number of
arguments it's easy to convert use of the || operator to
MySQL.
CREATE DATABASE or DROP DATABASE.
See section 7.4 Create database syntax.
% instead of mod(). % is supported for C programmers and
for compatibility with postgreSQL.
=, <>, <= ,<, >=,>, AND,
OR, or LIKE in a column statement
LAST_INSERT_ID.
See section 17.1.3 How can I get the unique ID for the last inserted row?
REGEXP or NOT REGEXP.
CONCAT() or CHAR() with 1 or more than 2 arguments. In
MySQL they can take any number of arguments.
BIT_COUNT(), ELT(), FROM_DAYS(), FORMAT(),
IF(), PASSWORD(), ENCRYPT(),
PERIOD_ADD(), PERIOD_DIFF(), TO_DAYS(),
or WEEKDAY().
TRIM to trim substrings. ANSI SQL only supports removal
of single characters.
STD(), BIT_OR and BIT_AND group functions.
MIN() or MAX() as normal functions, not only group
functions.
REPLACE instead of DELETE + INSERT.
See section 7.13 REPLACE syntax
The following functionality is missing in the current version of MySQL. For the priority of new extensions you should consult: The MySQL Todo list. That is the latest version of the Todo list in this manual. See section E List of thing we want to add to MySQL in the future..
The following will not work in MySQL:
SELECT * from table WHERE id IN (SELECT id from table2)
MySQL only supports INSERT ... SELECT... and REPLACE
... SELECT.... Independent sub-selects will be probably be availably in
3.22.0. One can now use the function IN() in other context
thought.
MySQL doesn't yet support SELECT ... INTO TABLE.... Currently
MySQL only supports SELECT ... INTO OUTFILE....
Transactions are not supported. MySQL will shortly support
atomic operations which are like transactions without rollback. With
atomic operations you can make a bunch of insert/select/whatever
commands and be guaranteed that no other thread will interfere. In this
context you won't usually need rollback. Currently you can do this with
the help of the LOCK TABLES/UNLOCK TABLES command. See section 7.19 LOCK TABLES syntax
Triggers are not supported. The planned update language will be able to handle stored procedures, but without triggers. Triggers usually slow down everything, even for queries when they aren't needed.
The FOREIGN KEY syntax in MySQL exists only for compatibility
with other SQL vendors CREATE TABLE commands: It doesn't do anything.
The FOREIGN KEY syntax without ON DELETE .. is mostly used
for documentation purposes. Some ODBC applications may uses this to
produce automatic WHERE clauses though, but this is usually
easy to override. FOREIGN KEY is sometimes used as a constraint check,
but this check is in practice unnecessary if one inserts rows in the tables
in the right order.
In MySQL one can go around the problem that ON DELETE
... isn't implement by adding the approative DELETE statement to
the application when one deletes record from a table that has
FOREIGN KEY. In practice this is as quick (in some case quicker)
and much more portable than using FOREIGN KEY.
Foreign keys are something that makes life very complicated, because the foreign key definition must be stored in some database and then the whole 'nice approach' of using only files that can be moved, copied and removed will be destroyed.
In the near future we will extend FOREIGN KEYS so that at least
the information will be saved and may be retrieved by mysqldump and
ODBC.
There is so many problems with the FOREIGN KEYs that we don't
know where to start.
INSERTING and
UPDATING records and in this case almost all FOREIGN KEY
checks are useless because one usually inserts records in the right
tables in the right order.
The only nice aspect of foreign key is that it gives ODBC and some other client programs the ability to see how a table is connected and use this to show connection diagrams and to help building applicatons.
MySQL will soon store the FOREIGN KEY definitions so that
a client can ask and receive an answer how the original connection was
made. The reason this can not be done is that the current .frm file format does not have any place for it.
MySQL doesn't support views, but this is on the TODO.
Some other SQL has -- as start comment. MySQL has # as the start comment character, even if the MySQL command line tool removes all lines that starts with --.
MySQL will not support this degenerated comment style because we have had many problems with automatic generated SQL queries that has used something like the following code:
UPDATE table_name SET credit=credit-!payment!
Where instead of !payment! we automaticly insert the value of the payment.
What do you think will happen when 'payment' is negative ?
Because 1--1 is legal in SQL, we think is terrible that '--' means start comment.
If you have a sql program in a textfile that contains -- comments you should use
replace " --" " #" < text-with-funny-comments.sql | mysql database. instead of the normal mysql database < text-with-funny-comments.sql
You can also change the -- to # comments in the command file with:
replace " --" " #" -- text-with-funny-comments.sql
and change them back with:
replace " #" " --" -- text-with-funny-comments.sql
Entry level SQL92. ODBC level 0-2.
GRANT. See section 7.21 GRANT syntax. (Compatibility function). This always succeeds. You should use the
MySQL privilege tables. See section 6.2 How does the privilege system work?
CREATE INDEX. See section 7.22 CREATE INDEX syntax (Compatibility function). This always succeeds. You
should create your index with CREATE TABLE. See section 7.6 CREATE TABLE syntax.
You can also use ALTER TABLE. See section 7.7 ALTER TABLE syntax.
DROP INDEX. See section 7.23 DROP INDEX syntax (Compatibility function). This always succeeds. You can use
ALTER TABLE to drop indexes. See section 7.7 ALTER TABLE syntax.
BLOB and TEXT types
If you want to GROUP BY or a ORDER BY on a BLOB or
TEXT field, you must make the field into a fixed length
object. The standard way to do this is with the SUBSTRING
functions. If you don't do this only the first max_sort_length
(default=1024) will considered when sorting.
SELECT comment from table order by substring(comment,20);
MySQL doesn't support COMMIT-ROLLBACK. The problem with COMMIT-ROLLBACK is that for it to handle this efficiently it would require a completely different table layout than MySQL uses today. MySQL would also need extra threads that do automatic cleanups on the tables and the disk space needed would be much higher. This would make MySQL about 2-4 times slower than it is today. One of the reasons that MySQL is so much faster than almost all other SQL databases (typical times are at least 2-3 times faster) is the lack of COMMIT-ROLLBACK.
For the moment, we are much more for implementing the SQL server language (stored procedures). With this you very seldom really need COMMIT-ROLLBACK, and you can do many more things without losing any speed.
Loops that need transactions can normally be coded with the help of
LOCK TABLES and one doesn't need cursors when one can update records
on the fly.
We have transactions and cursors on the TODO but not quite prioritised. If
it is implemented it will be as a option to CREATE TABLE. That
means that COMMIT-ROLLBACK will only work on those tables and only those
tables will be slower.
We at TcX have a greater need for a real fast database than a 100% general database. Whenever we find a way to implement these without any speed loss we will probably do it, but for the moment there is many more important things to do. Check the TODO for how we prioritise things at the moment. Customers with higher levels of support can alter this, so things may be reprioritised.
The current problem is actually ROLLBACK. Without ROLLBACK
you can do anything with LOCK TABLES. To support ROLLBACK
MySQL would had to be changed to store all old records that was
updated and revert everything back to the starting point if
ROLLBACK was issued. For simple cases this isn't that hard to do
(the current isamlog could be used for this), but if one wants to have
ROLLBACK with ALTER/DROP/CREATE TABLE it would make
everything much harder to implement.
To avoid using ROLLBACK one can do:
LOCK TABLES ...
UNLOCK TABLES
This is usually much faster, but not always. The only thing this doesn't handle if someone does a kill on the process.
One can also use functions to update things in one operation. By doing all updates relatively and/or only update those fields that actually have changed one can get a very efficient application.
For example, when we are doing updates on some customer information, we
only update the customer data that has changed and only test that not
any of the changed data, or data that depends on the changed data, has
changed in the original row. The test for change is down with the
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", and then we show the old row versus
the new row in a window. The user can then decide which version of the
customer record he should use.
This gives us something like 'column locking' but actually even better, because we only update some of the columns with relative information. This means that a typical update statement looks something like:
UPDATE tablename SET pay_back=pay_back+'relative change' UPDATE customer set customer_date='current_date', address='new address', phone='new phone', money_he_owes_us=money_he_owes+'new_money' where customer_id=id and address='old address' and phone='old phone';
As you can see, this is very efficient and even if another client has changed the 'money_he_owes_us' or 'pay_back' amount this will still work.
In many cases, users have wanted ROLLBACK and/or LOCK
TABLES to manage unique identifiers for some tables. This can be
handled much more efficiently by using an AUTO_INCREMENT column
and the MySQL API function
mysql_insert_id. See section 17.1.3 How can I get the unique ID for the last inserted row?
At TcX we have never had any need for row level locking as we have always been able to code around it. I know some cases that really need row locking, but they are very few. If you want to have row level locking you can do something like:
UPDATE table_name SET row_flag=1 WHERE id=ID;
MySQL returns affected rows = 1 if the row was found and row_flag
wasn't 1 in the original document. On the TODO there is GET_LOCK and
RELEASE_LOCK for those that want to implement application level
locking.
MySQL has a advanced but non-standard security/privilege system.
The basic function of the MySQL privilege system is to give a username on a host select,insert,update and delete privileges on a database.
Extra function includes the ability to have a anonymous user and give
permission to use MySQL specific funtions like LOAD DATA
INFILE.
In MySQL the combination of host and user is the unique identity. Don't think of users, think of host+user and everything should be much clearer. You can for example have a user named 'Robb' at two different hosts (with different privileges) in MySQL without any conflicts.
The MySQL privilege system makes sure that each user may do exactly the things that they are supposed to be allowed to do. The system decides to grant different privileges depending on which xuser connects from which host to which database.
You can always test your privileges with the script mysqlaccess,
which Yves Carlier has provided for the MySQL distribution.
See section 6.7 Why do I get this Access denied? error.
The following switches to mysqld is relevant to security:
--skip-grant-tables
--skip-name-resolve
--skip-networking
--secure
get_hostbyname resolves
back to the original hostname. This is done to make it harder for
someone on the outside to get access by simulating another host.
This is turned off by default since it sometimes takes a long time to
check this.
All privileges are stored in three tables. user, host and
db.
Everything granted in the user table is valid for every database
that cannot be found in the db table. For this reason, it might
be wise to grant users (apart from superusers) privileges on a
per-database basis only.
The host table is mainly there to maintain a list of "secure"
servers. At TcX host contains a list of all machines on the
local network. These are granted all privileges.
The connecting user's privileges are calculated by the following algorithm:
| Table | Sorted by |
| host | host without wild/hosts with wild/empty hosts |
| db | host without wild/hosts with wild/empty hosts |
| user | host/user |
host = "". Within each host sort by
user using the same rules. Finally, in the db table, sort by db
using the same rules. In the steps below, we will look through the
sorted tables and always use the first match found.
user table
using the first match found. empty user.
Call this set of privileges
Priv.
db table
using the first match found.
host = "" for the entry found in the db table, AND
P with the privileges for the host in the host table, i.e.
remove all privileges that are not "Y" in both. (If host <> "",
P is not affected. In suchcases, host must have matched the
connecting host's name at least partially. Therefor it can be assumed
that the privileges found in this row match the connecting host's
profile.)
user
table, i.e. add all privileges that are "Y" in user.
mysqladmin reload to make the changes take effect.
The connecting user gets the set of privileges P.
Let's show an example of the sorting and matching! Suppose that the user
table contains this:
+-----------+----------+- | Host | User | ... +-----------+----------+- | % | root | ... | % | jeffrey | ... | localhost | root | ... | localhost | | ... +-----------+----------+-Then the search order will be:
localhost/any line, not by the any/jeffrey line. The
first match found is used!
So if you have access problems, print out the user table, sort it by
hand, and see where the match is being made.
Here follows an example to add a user 'custom' that can connect from hosts
'localhost', 'server.domain' and 'whitehouse.gov'. He wants to have password
'stupid'. The database 'bankacount' he only want to use from 'localhost' and
the 'customer' database he wants to be able to reach from all three hosts.
shell> mysql mysql.
mysql> insert into user (host,user,password)
values('localhost','custom',password('stupid'));
mysql> insert into user (host,user,password)
values('server.domain','custom',password('stupid'));
mysql> insert into user (host,user,password)
values('whitehouse.gov','custom',password('stupid'));
mysql> insert into db
(host,db,user,Select_priv,Insert_priv,Update_priv,Delete_priv,
Create_priv,Drop_priv)
values
('localhost','bankacount','custom','Y','Y','Y','Y','Y','Y');
mysql> insert into db
(host,db,user,Select_priv,Insert_priv,Update_priv,Delete_priv,
Create_priv,Drop_priv)
values
('%','customers','custom','Y','Y','Y','Y','Y','Y');
You can of course also use xmysqladmin, mysql_webadmin, mysqladmin and even
xmysql to insert/change and update values in the privilege tables.
You can find these utilities in the Contrib directory.
The grant tables privileges on rows are select, insert, update and delete.
The table and database privileges are create and drop. Create and drop are for both tables and databases. Since a user with a drop grant can delete any table, this is the same thing as a drop grant for the database.
Other privileges give the right to use files (for LOAD DATA INFILE and
SELECT INTO OUTFILE) and to use the administrative commands
shutdown, reload, refresh and process.
The privilege system is based on 3 tables.
user table
user
table has the following columns:
| Field | Type | Key | Default |
| Host | char(60) | PRI | "" |
| User | char(16) | PRI | "" |
| Password | char(16) | - | "" |
| Select_priv | enum('N','Y') | - | N |
| Insert_priv | enum('N','Y') | - | N |
| Update_priv | enum('N','Y') | - | N |
| Delete_priv | enum('N','Y') | - | N |
| Create_priv | enum('N','Y') | - | N |
| Drop_priv | enum('N','Y') | - | N |
| Reload_priv | enum('N','Y') | - | N |
| Shutdown_priv | enum('N','Y') | - | N |
| Process_priv | enum('N','Y') | - | N |
| File_priv | enum('N','Y') | - | N |
db table
Contains which databases a host+user is allowed to use, and what he can
do with the tables in each database. The db table has the
following columns:
| Field | Type | Key | Default |
| Host | char(60) | PRI | "" |
| Db | char(32) | PRI | "" |
| User | char(16) | PRI | "" |
| Select_priv | enum('N','Y') | - | N |
| Insert_priv | enum('N','Y') | - | N |
| Update_priv | enum('N','Y') | - | N |
| Delete_priv | enum('N','Y') | - | N |
| Create_priv | enum('N','Y') | - | N |
| Drop_priv | enum('N','Y') | - | N |
host table
Is only used in big networks as a lookup for empty host entries in the
db table. This means that if you want a user to be able to use the
database from all hosts in your network, you should put " as the host
name in the db table. In this case the host table should contain
a entry for every host in your network. The host table has the
following columns:
| Field | Type | Key | Default |
| Host | char(60) | PRI | "" |
| Db | char(32) | PRI | "" |
| Select_priv | enum('N','Y') | - | N |
| Insert_priv | enum('N','Y') | - | N |
| Update_priv | enum('N','Y') | - | N |
| Delete_priv | enum('N','Y') | - | N |
| Create_priv | enum('N','Y') | - | N |
| Drop_priv | enum('N','Y') | - | N |
% and _. Leaving any of these columns empty is
equivalent to setting it to '%'.
localhost, a hostname, an IP number or a
string with wildcards. An empty host in the db table means any host in
the host table. An empty host in the host or user table means any
host that can create a TCP connection to your server.
user table will be processed
as a no-name user.
db table.
This means that a superuser only needs to be in the user table with all
privilege-flags set to Y.
123.444.444.% in the host table to give
every user on a IP C-net access. To avoid the possiblity that somebody
tries to fool this setup by nameing a host to
123.444.444.somewhere.com to fool the permission system. To avoid
this problem MySQL disallows all hostnames that start with
digits and a dot. So if your host is named something like
1.2.foo.com it will never be allowed with name matching. Use the
IP number in this case.
To add privileges to the MySQL database:
This assumes the current user has insert privileges for the mysql db
table and reload privileges. The server (mysqld) has to be running. If
it is not, start it with safe_mysqld --log &.
> mysql mysql
insert into user values ('%','monty',password('something'),'Y','Y','Y','Y','Y','Y','Y','Y','Y','Y') ;
insert into user (host,user,password) values('localhost','dummy',") ;
insert into user values ('%','admin',",'N','N','N','N','N','N','Y','N','Y','Y') ;
quit
> mysqladmin reload
This makes three new users:
Monty
admin
mysqladmin reload,
mysqladmin refresh and mysqladmin processlist. May be granted
individual database privileges through table db.
dummy
db.
The default privileges (set in `scripts/mysql_install_db')
let root do anything. Any user can do anything with any database whose
name is 'test' or starts with 'test_'. A normal user can't use
mysqladmin shutdown or mysqladmin processlist. See the
script (`scripts/mysql_install_db') for an example on how to add
other users.
The privilege tables are read into mysqld with mysqladmin reload.
A common mistake is to forget that passwords are stored encrypted, which leads to something like:
INSERT INTO user VALUES ('%','jeffrey','bLa81m0','Y','Y','Y','N','N','N','N','N', 'N','N');
Then (of course) a mysqladmin reload to make the authentication
change take effect, then trying to connect to the server:
$ ./mysql -h sqlserver -u jeffrey -p bLa81m0 test
Access denied
Try this instead:
INSERT INTO user VALUES
('%','jeffrey',password('bLa81m0'),'Y','Y','Y','N','N','N','N','N','N','N');
And like before mysqladmin reload to make the authentication change
take effect.
Now things should work.
Access denied? error.--without-grant-tables option. Now you can change the MySQL
grant tables and use the script mysqlaccess to check if your
grants works. mysqladmin reload tells the mysqld demon to
start using the new grant tables.
mysql -u user database or
mysql -uuser -ppassword database.
mysql -u user database then you have a problem with
the 'user' table. Check this by doing mysql -u root mysql and
select * from user. You should get an entry with 'hostname' and
'user' matching your computers hostname and your username. If the client
and the server is running on the same host and you haven't used the
--host option to mysql and you are not using MIT threads,
'localhost' is a synonym for your hostname.
Access denied error message will tell you who you are trying
to log in as, from which host you are trying to log in from and if you
was using a password or not. You should normally have one entry in the
user table that exactly matches your host and user, exactly as
given in the error message.
mysql -u root test works but mysql -h your_hostname -u
root test gives 'Access denied' then you don't have the right name for
your host in the user table. For example if you have an entry with host
'tcx' in the 'user' table, but your DNS tells MySQL that your
hostname is 'tcx.subnet.se' then the entry will not work. Test by adding
a record with the IP of your host in the 'user' table. You can,
natuarally, also add a host with a wildcard (for example 'tcx%') in the
'user table' (but using hostnames ending with % is pretty insecure).
mysql -u user database works on the server machine, but
mysql -u host -u user database doesn't work on another client
machine, then you don't have the client machine in the 'user' or the
'db' table.
mysql -u user test works but mysql -u user
other_database doesn't work, you don't have the other_database in the
'db' table.
SELECT
... INTO OUTFILE or LOAD DATA SQL commands then you probably
don't have the file_priv privilege set for you in the user table.
mysqld demon with:
--debug=d,general,query. This will print info about the host and
user that tries to connect and also information about each command
issued. See section 18.9 Debugging MySQL.
mysqldump mysql command. And as always post your problem with the
mysqlbug script.
A string may have ' or " around it.
\ is a escape character. The following escape characters are recognised:
\0
\n
\t
\r
\b
\'
' character.
\"
" character.
\\
\ character.
\%
% character. This is used in wild-card strings to search after
%.
\_
_ character. This is used in wild-card strings to search after
_.
A ' inside a string started with ' may be written as ". A " inside a string started with " may be written as "".
Some example selects that shows how it works.
MySQL> select 'hello', "'hello'", '""hello""', "'h"e"l"l"o"', "hel""lo"; 1 rows in set (0.00 sec) +-------+---------+-----------+-------------+--------+ | hello | 'hello' | ""hello"" | 'h'e'l'l'o' | hel"lo | +-------+---------+-----------+-------------+--------+ | hello | 'hello' | ""hello"" | 'h'e'l'l'o' | hel"lo | +-------+---------+-----------+-------------+--------+
mysql> select 'hello', "hello", '""hello""', "'ello", 'e"l"lo', '\'hello'; 1 rows in set (0.00 sec) +-------+-------+-----------+-------+--------+--------+ | hello | hello | ""hello"" | 'ello | e'l'lo | 'hello | +-------+-------+-----------+-------+--------+--------+ | hello | hello | ""hello"" | 'ello | e'l'lo | 'hello | +-------+-------+-----------+-------+--------+--------+
mysql> select "This\nIs\nFour\nlines"; 1 rows in set (0.00 sec) +--------------------+ | This Is Four lines | +--------------------+ | This Is Four lines | +--------------------+
If you want to insert binary data into a blob the following characters must be represented by escape sequences:
\0
\
'
"
Integers are just a sequence of digits. Floats use . as a decimal
separator.
Examples of valid numbers are: 1221, 294.42,
-32032.6809e+10.
NULL
When using the text file export formats, NULL may be represented
by \N. See section 7.14 LOAD DATA INFILE syntax
Database, table, index and column names all follow the same rules in MySQL.
A name may use alphanumeric characters from the default character set. This is by default ISO-8859-1 Latin1 but may be changed when compiling MySQL.
Since MySQL needs to be able to decide if something is a name or a number the following special cases occurs.
1e. This is because
expressions like 1e+1 may be interpreted like the expression
1e + 1 or the number 1e+1.
So punctuation characters like . and @ are not allowed
since they will be used to extend MySQL.
The following column types are supported:
| Name | Description | Size |
| TINYINT[(D)] [UNSIGNED] [ZEROFILL] | A very small integer. Signed range -128 - 127. Unsigned range 0 - 255. | 1 |
| SMALLINT[(D)]. [UNSIGNED] [ZEROFILL] | A small integer. Signed range -32768 - 32767. Unsigned range 0 - 65535. | 2 |
| MEDIUMINT[(D)] [UNSIGNED] [ZEROFILL] | A medium integer. Signed range -8388608-8388607. Unsigned range 0 - 16777215. | 3 |
| INT[(D)] [UNSIGNED] [ZEROFILL] | A normal integer. Signed range -2147483648 - 2147483647. Unsigned range 0 - 4294967295. | 4 |
| BIGINT[(D)] [UNSIGNED] [ZEROFILL] | A large integer. Signed range -9223372036854775808 - 9223372036854775807. Unsigned Range 0 - 18446744073709551615. | 8 |
| FLOAT(Precision) | A small floating point number. Precision can be 4 or 8. FLOAT(4) is a single precision number and FLOAT(8) is a double precision number (se the DOUBLE entry). This syntax is for ODBC compatibility. Range -3.402823466E+38F - -1.175494351E-38, 0, -1.175494351E-38 - 3.402823466E+38F. | 4 |
| FLOAT[(M,D)] | A small floating point number. Cannot be unsigned. Range -3.402823466E+38F - -1.175494351E-38, 0, -1.175494351E-38 - 3.402823466E+38F. | 4 |
| DOUBLE PRECISION[(M,D)] | A normal floating point number. Cannot be unsigned. Range -1.7976931348623157E+308 - -2.2250738585072014E-308, 0, 2.2250738585072014E-308 - 1.7976931348623157E+308. | 8 |
| REAL[(M,D)] | Same as DOUBLE | 8 |
| DECIMAL [(M,D)] | An unpacked floating point number. Cannot be unsigned. Currently the same range maximum range as a double. Behaves as a CHAR column | M+D |
| NUMERIC [(M,D)] | Same as DECIMAL | M+D |
| TIMESTAMP [(M)] | An automatic timestamp. | 4 |
| DATE | A type to store date information. Uses the "YYYY-MM-DD" syntax, but may be updated with a number or a string. Understands at least the following syntaxes: 'YY-MM-DD', 'YYYY-MM-DD', 'YYMMDD', 'YYMM', 'YY'. Range 0000-00-00 to 9999-12-31. | 4 |
| TIME | A type to store time information. Uses the "HH:MM:SS" syntax, but may be updated with a number or a string. Understands at least the following syntaxes: 'HH:MM:DD, 'HHMMDD', 'HHMM', 'HH'. | 3 |
| DATETIME | A type to store date and time information. Format "YYYY-MM-DD HH:MM:SS". Takes 8 bytes. Range '0000-01-01 00:00:00' - '9999-12-31 23:59:59'. | 8 |
| CHAR(M) [binary] | A fixed length string that is always filled up with spaces to the specified length. Range 1 - 255 characters. All end space are removed when retrieved. Is sorted and compared case insensitively unless the binary keyword is given. | M |
| VARCHAR(M) [binary] | A variable length string that is stored with its length. Maximum range 1 - 255 characters. Is sorted and compared case insensitively unless the binary keyword is given. | L+1 |
| TINYTEXT and TINYBLOB |
A TEXT/BLOB with max length of 255 characters. | L+1 |
| TEXT and BLOB |
A TEXT/BLOB with max length of 65535 characters. | L+2 |
| MEDIUMTEXT and MEDIUMBLOB |
A TEXT/BLOB with max length of 16777216 characters. | L+3 |
| LONGTEXT and LONGBLOB |
A TEXT/BLOB with max length of 4294967295 characters. | L+4 |
| ENUM('value','value2',...) | A string object that can have only one set of allowed values. See section 7.2.1 More about data types. | 1 or 2 |
| SET('value','value2',...) | A string object that can have one or many values of a set of allowed values. See section 7.2.1 More about data types. | 1-8 |
In the above table L means the actual length of a instance and M the maximum length. So L+1 for "abcd" means 5 bytes in the database.
If you use any data type with a L in the length field you will get a variable length record format.
All integer types can have a optional argument unsigned. This
can be used when you only want to allow positive numbers in the column
or you need a little bigger numerical range for the column.
Also for all integer columns the optional argument ZEROFILL means
that the column will be padded with zeroes up to the maximum length.
Max display size and decimals are for formatting and calculation of max column width.
When storing a value in a integer that is outside its range,
MySQL stores the maximum (or minimum) possible value. When
doing an ALTER TABLE or LOAD DATA INFILE one gets these
conversions as 'warnings'. We have on the TODO to make INSERT and
UPDATE also can return warnings, but this is scheduled for the next
protocol change.
For example when storing -999999999999999 into a int column the
value end up as -2147483648. And 9999999999999999 end up
as 2147483647.
And if the int is unsigned the stored values above becomes 0 and
4294967296.
The same rules goes for all other integer types.
When returning data for an int(4) column that does not fit in it
MySQL will return 9.99. And is an UPDATE a warning will
be issued.
Note that a type like decimal(4,2) means maximum 4 characters
with two decimal points. That gives a range between -.99 ->
9.99.
To avoid some rounding problems, MySQL always rounds everything
that it stores in any floating point column according to the number of
decimals. This means that 2.333 stored into float(8,2) is
stored as 2.33.
TIMESTAMP type
Has a range of 1 Dec 1970 time 0.00 to sometime in the year 2106 and a
resolution of one second. Will be automatically updated if not used in a
statement that updates a row or if set to NULL. Can be a (part
of) a index. Note that if you have many timestamp columns in a row, then
only the first timestamp column will be automatically updated. Any
timestamp column will be set to the current time if set to
NULL. Depending on the display size one gets one of the following
formats: "YYYY-MM-DD HH:MM:SS", "YY-MM-DD HH:MM:SS", "YYYY-MM-DD" or
"YY-MM-DD".
TEXT and BLOB types
These are objects that can have a variable length without upper limit.
All TEXT and BLOB objects are stored with is length (saved in 1 to 4
bytes depending on the type of object). The maximum TEXT and
BLOB length you can use is dependent on available memory and
client buffers. The only differences between TEXT and BLOB
is that TEXT is sorted and compared case insensitively while
BLOB is compared case insensitive (by character
values). TEXT and BLOB objects CANNOT be index.
A BLOB is a binary large object which can hold any amount of data. There are 4 kinds of blobs See section 7.2 Column types.. Normally one can regard a BLOB as a VARCHAR without a specified limit.
TEXT is a BLOB that is sorted and compared case
insensitively.
A BLOB/TEXT column may not be bigger that the message
buffer. Note that you have to change the message buffer on both the
server and the client. See section 11.1 How does one change the size of MySQL buffers?.
MyODBC defines BLOBs as LONGVARBINARY and
TEXTs as LONGVARCHAR.
Restrictions for BLOB and TEXT columns:
BLOB or TEXT cannot be a index or a part of a index
BLOB or TEXT only the first
max_sort_length (default 1024) of the blob is used. This value
can be changed by the -O option when starting the mysqld
demon. One can group on an expression involving a BLOB/
TEXT: SELECT id,SUBSTR(blob,1,100) GROUP BY 2
BLOB and TEXT as
there is for CHAR and VARCHAR.
ENUM type
A string object that can have only one set of allowed values. The value
to be stored may be given case independently. If one tries to store a
non-existing value, "" is stored. If used in a number context this
object returns/stores the value index. If there is less than 255
possible values this object occupies 1 byte, else two bytes (with a
maximum of 65535 different values). Note that if a integer is put in the
ENUM you get the corresponding string with the first counting as
number zero. Sorting on ENUM types is done after the order of the
strings in the enum.
For example the column test ENUM("one","two", "three") can have
any off these values:
"one" "two" "three"
SET type
A string object that can have one or many values of a set of allowed
values. Each value is separated by a ','. If used in a number context
this object returns/stores the bit positions of the used values. This
object occupies (number_of_different_values-1)/8+1 bytes, rounded up to
1,2,3,4 or 8. One can't have more than 64 different values. Note that if
a integer is put in the SET you get the corresponding string with
the first bit corresponding to the first string. Sorting on SET
types is done numerically.
For example the column test SET("one","two") can have any off
these values:
"" "one" "two" "one,two"
Try to use the most precise type in all cases. For example for a integer
between 1-99999 a unsigned mediumint is the best type.
A common problem is representing monetary values accurately. In
MySQL you should use the DECIMAL type. This is stored as
a string so no loss of accuracy should occur. If accuracy is not to
important the DOUBLE type may also be good enough.
To get real high precision you can always convert to a fixed point type
stored in a BITINT. This allows you to do all calculation with
integers and only convert the result back to floating point.
You can have indexes on all MySQL columns except BLOB
and TEXT types. Using indexes on the relevant columns is the most
important thing in getting your selects to run fast.
For CHAR and VARCHAR columns you can have a index on a
prefix. The example below show how to create a index for the first 10
characters of a column. This is much faster and requires less disk space
than having a index on the whole column.
CREATE TABLE test ( name CHAR(200), KEY name (last_name(10));
MySQL can have one index on parts of different columns.
A multiple column index can be considered as a sorted array where the columns are concatenated. This makes for fast queries where the first column in the index is a known quantity and the other columns are not.
Suppose that you have a table:
CREATE TABLE test ( id INT, last_name CHAR(30), first_name CHAR(30), PRIMARY KEY (id), INDEX name (last_name,first_name));
Then the index name is a index over last_name and first_name.
The name index will be used in the following queries:
SELECT * FROM test WHERE last_name="Widenius";
SELECT * FROM test WHERE last_name="Widenius" AND first_name="Michael";
SELECT * FROM test WHERE last_name="Widenius" AND
(first_name="Michael" OR first_name="Monty");
SELECT * FROM test WHERE last_name="Widenius" and
first_name >="M" and first_name < "N";
The name index will NOT be used in the following queries:
SELECT * FROM test WHERE first_name="Michael"; SELECT * FROM test WHERE last_name="Widenius" or first_name="Michael";
To support easier use of code from different SQL vendors, MySQL does supports the following mappings:
| binary(num) | char(num) binary |
| char varying | varchar |
| float4 | float |
| float8 | double |
| int1 | tinyint |
| int2 | smallint |
| int3 | mediumint |
| int4 | int |
| int8 | bigint |
| long varbinary | blob |
| long varchar | text |
| middleint | mediumint |
| varbinary(num) | varchar(num) binary |
SELECT and WHERE clauses
A select_expression or where_definition can consist of any
expression using the following functions:
In the examples below the output of the mysql program has been
shortended. So
mysql> select mod(29,9); 1 rows in set (0.00 sec) +-----------+ | mod(29,9) | +-----------+ | 2 | +-----------+
Has been converted to
mysql> select mod(29,9); -> 2
(
)
mysql> select 1+2*3; -> 7 mysql> select (1+2)*3; -> 9
+
-
*
/
NULL.
mysql> select 102/(1-1); -> NULL
These have a range of maximum 64 bits because MySQL uses bigint (64 bit) arithmetic.
|
mysql> select 29 | 15; -> 31
&
mysql> select 29 & 15; -> 13
BIT_COUNT()
mysql> select bit_count(29); -> 4
All logical function return 1 (TRUE) or 0 (FALSE).
NOT
!
mysql> select NOT 1; -> 0 mysql> select NOT NULL; -> NULL mysql> select ! (1+1); -> 0 mysql> select ! 1+1; -> 1
OR
||
mysql> select 1 || 0; -> 1 mysql> select 0 || 0; -> 0 mysql> select 1 || NULL; -> 1
AND
&&
mysql> select 1 && NULL; -> 0 mysql> select 1 && 0; -> 0
Returns 1 (TRUE) or 0 (FALSE). These functions work for both numbers and strings. MySQL uses the following rules to decide how the compare is done:
TIMESTAMP or DATETIME column and
the other argument is a constant. In this case the constant is converted
to a timestamp before the comparasion. All this is to be more ODBC
friendly.
=
mysql> select 1 = 0; -> 0 mysql> select "0" = 0; -> 1 mysql> select "0.0" = 0; -> 1 mysql> select "0.01" = 0; -> 0 mysql> select ".01" = 0.01; -> 1
<>
!=
mysql> select ".01" <> "0.01"; -> 1 mysql> select .01 <> "0.01"; -> 0 mysql> select "zapp" <> "zappp"; -> 1
<=
mysql> select 0.1 <= 2; -> 1
<
mysql> select 2 <= 2; -> 1
>=
mysql> select 2 >= 2; -> 1
>
mysql> select 2 > 2; -> 0
ISNULL(A)
A is NULL else 0. Same as (A = NULL).
mysql> select isnull(1+1); -> 0 mysql> select isnull(1/0); -> 1
A BETWEEN B AND C
A is bigger or equal as B and A is smaller or equal
to C. Does the same thing as (A >= B AND A <= C) if the
all arguments are of the same type. It's the first argument (A)
that decides how the comparison should be done! If A is a string
expression, compare as strings. If A is a integer expression
compare as integers, else compare as reals.
mysql> select 1 between 2 and 3; -> 0 mysql> select 2 between 2 and 3; -> 1 mysql> select 2 between 2 and "3"; -> 1 mysql> select 2 between 2 and "x-3"; -> 0
expr IN (value,...)
IN list, else it
returns 0. If all values are constants, then all values are evaluated
according to the type of expr and sorted. The search for them item is
then done by using a binary search. This means IN is very quick
when used with constants in the IN part.
mysql> select 2 in (0,3,5,"wefwf"); -> 0 mysql> select "wefwf" in (0,3,5,"wefwf"); -> 1
expr NOT IN (value,...)
NOT (expr IN (value,...))
expr LIKE expr
LIKE you have two wild characters.
% | Matches any number of characters, even zero characters. |
_ | Matches exactly one character. |
\% | Matches one %.
|
\_ | Matches one _.
|
mysql> select "David!" like "David_"; -> 1 mysql> select "David!" like "David\_"; -> 0 mysql> select "David_" like "David\_"; -> 1 mysql> select "David!" like "%D%v%"; -> 1
NOT (expr LIKE expr).
mysql> select "Monty!" regexp "m%y%%"; -> 0 mysql> select "Monty!" regexp ".*"; -> 1
NOT (expr REGEXP expr).
mysql> select strcmp("text", "text2"); -> -1
mysql> select strcmp("text2", "text"); -> 1
mysql> select strcmp("text", "text"); -> 0
IFNULL(A,B)
A is not NULL it returns A, else B.
mysql> select ifnull(1,0); -> 1 mysql> select ifnull(0,10); -> 0 mysql> select ifnull(1/0,10); -> 10
IF(A,B,C)
A is true (A <> 0 and A <> NULL) then return
B, else return C.
mysql> select if(1>2,2,3); -> 3
All mathematical functions returns NULL in the case of a error.
-
mysql> select - 2; -> -2
ABS()
mysql> select abs(2); -> 2 mysql> select abs(-32); -> 32
SIGN()
mysql> select sign(-32); -> -1 mysql> select sign(0); -> 0 mysql> select sign(234); -> 1
MOD()
%
mysql> select mod(234, 10); -> 4 mysql> select 253 % 7; -> 1 mysql> select mod(29,9); -> 2
FLOOR()
mysql> select floor(1.23); -> 1 mysql> select floor(-1.23); -> -2
CEILING()
mysql> select ceiling(-1.23); -> -1 mysql> select ceiling(1.23); -> 2
ROUND(N)
N to a integer.
mysql> select round(-1.23); -> -1 mysql> select round(-1.58); -> -2 mysql> select round(1.58); -> 2
ROUND(Number,Decimals)
Number to a number with Decimals decimals.
mysql> select ROUND(1.298, 1); -> 1.3
EXP(N)
e (the base of natural logarithms) raised to
the power of N.
mysql> select exp(2); -> 7.389056 mysql> select exp(-2); -> 0.135335
LOG(X)
X.
mysql> select log(2); -> 0.693147 mysql> select log(-2); -> NULL
LOG10(X)
X.
mysql> select log10(2); -> 0.301030 mysql> select log10(100); -> 2.000000 mysql> select log10(-100); -> NULL
POW(X,Y)
POWER(X,Y)
X raised to the power of Y.
mysql> select pow(2,2); -> 4.000000 mysql> select pow(2,-2); -> 0.250000
sqrt(X)
X.
mysql> select sqrt(4); -> 2.000000 mysql> select sqrt(20); -> 4.472136
PI()
mysql> select PI(); -> 3.141593
COS(X)
X, where X is given in radians.
mysql> select cos(PI()); -> -1.000000
SIN(X)
X, where X is given in radians.
mysql> select sin(PI()); -> 0.000000
TAN(X)
X, where X is given in radians.
mysql> select tan(PI()+1); -> 1.557408
ACOS(X)
X; that is the value whose cosine is
X. If X is not in the range -1 to 1 NULL is
returned.
mysql> select ACOS(1); -> 0.000000 mysql> select ACOS(1.0001); -> NULL mysql> select ACOS(0); -> 1.570796
ASIN(X)
X; that is the value whose sine is
X. If X is not in the range -1 to 1 NULL is
returned.
mysql> select ASIN("0.2"); -> 0.201358
mysql> select ASIN("foo"); -> 0.000000
ATAN(X)
X; that is the value whose tangent is
X.
mysql> select ATAN(2); -> 1.107149 mysql> select ATAN(-2); -> -1.107149
ATAN2(X,Y)
X and Y. It is
similar to calculating the arc tangent of Y / X, except that the
signs of both arguments are used to determine the quadrant of the
result.
mysql> select ATAN(-2,2); -> -0.785398 mysql> select ATAN(PI(),0); -> 1.570796
COT(N)
N.
mysql> select COT(12); -> -1.57267341 mysql> select COT(0); -> NULL
RAND([X])
0 <= x <= 1.0, using the integer
expression X as the optional seed value.
mysql> SELECT RAND(); -> 0.5925 mysql> SELECT RAND(20); -> 0.1811 mysql> SELECT RAND(20); -> 0.1811 mysql> SELECT RAND(); -> 0.2079 mysql> SELECT RAND(); -> 0.7888
MIN(X,Y...)
GROUP BY functions. The arguments are compared as numbers. If no
records are found NULL is returned.
mysql> SELECT MIN(2,0); -> 0 mysql> SELECT MIN(34,3,5,767); -> 3 mysql> SELECT MIN(a) from table where 1=0; -> NULL
MAX(X,Y...)
GROUP BY functions. The arguments are compared as numbers. If no
records are found NULL is returned.
mysql> SELECT MAX(34,3,5,767); -> 767 mysql> SELECT MAX(2,0,4,5,34); -> 34 mysql> SELECT MAX(a) from table where 1=0; -> NULL
DEGREES(N)
N converted from radians to degrees.
mysql> select DEGREES(PI()); -> 180.000000
RADIANS(N)
N converted from degrees to radians.
mysql> select RADIANS(90); -> 1.570796
TRUNCATE(Number, Decimals)
Number to Decimals decimals.
mysql> select TRUNCATE(1.223,1); -> 1.2 mysql> select TRUNCATE(1.999,1); -> 1.9 mysql> select TRUNCATE(1.999,0); -> 1
ASCII(S)
S. If
S is NULL return NULL.
mysql> SELECT ascii(2); -> 50
mysql> SELECT ascii("dx"); -> 100
CHAR(X,...)
NULLs are skipped.
mysql> SELECT char(77,121,83,81,"76"); -> "MySQL"
CONCAT(X,Y...)
mysql> SELECT CONCAT("My", "S", "QL"); -> "MySQL"
LENGTH(S)
OCTET_LENGTH(S)
CHAR_LENGTH(S)
CHARACTER_LENGTH(S)
mysql> SELECT length("text"); -> 4
mysql> SELECT octet_length("text"); -> 4
LOCATE(A,B)
POSITION(B IN A)
A substring in B. The first position
is 1. Returns 0 if A is not in B.
mysql> select locate("bar", "foobarbar"); -> 4
mysql> select locate("xbar", "foobar"); -> 0
INSTR(A,B)
B in string A. This is
the same as LOCATE with swapped parameters.
mysql> select instr("foobarbar", "bar"); -> 4
mysql> select instr("xbar", "foobar"); -> 0
LOCATE(A,B,C)
A in string B starting
at C.
mysql> select locate("bar", "foobarbar",5); -> 7
LEFT(str,length)
mysql> select left("foobarbar", 5); -> "fooba"
RIGHT(A,B)
SUBSTRING(A FROM B)
B characters from end of string A.
mysql> select right("foobarbar", 5); -> "arbar"
mysql> select substring("foobarbar" from 5); -> "arbar"
LTRIM(str)
mysql> select ltrim(" barbar"); -> "barbar"
RTRIM(str)
TRIM([[ BOTH | LEADING | TRAILING] [ A ] FROM ] B)
A prefixes and/or suffixes
removed from B. If BOTH, LEADING and
TRAILING isn't used BOTH are assumed. If A is not
given, then spaces are removed.
mysql> select trim(" bar "); -> "bar"
mysql> select trim(leading "x" from "xxxbarxxx"); -> "barxxx"
mysql> select trim(both "x" from "xxxbarxxx"); -> "bar"
mysql> select trim(trailing "xyz" from "barxxyz"); -> "barx"
SOUNDEX(S)
S. Two strings that sound 'about the
same' should have identical soundex strings. A 'standard' soundex string
is 4 characters long, but this function returns an arbitrary long
string. One can use SUBSTRING on the result to get a 'standard'
soundex string. All non alpha characters are ignored in the given
string. All characters outside the A-Z range are treated as vocals.
mysql> select soundex("Hello"); -> "H400"
mysql> select soundex("Bдttre"); -> "B360"
mysql> select soundex("Quadratically"); -> "Q36324"
SUBSTRING(A, B, C)
SUBSTRING(A FROM B FOR C)
MID(A, B, C)
A starting at B with C
chars. The variant with FROM is ANSI SQL 92 syntax.
mysql> select substring("Quadratically",5,6); -> ratica
SUBSTRING_INDEX(String, Delimiter, Count)
String after Count
Delimiters. If Count is positive the strings are searched
from left else if count is negative the substrings are searched and
returned from right.
mysql> select substring_index("www.tcx.se", ".", 2); -> "www.tcx"
mysql> select substring_index("www.tcx.se", ".", -2); -> "tcx.se"
SPACE(N)
N spaces.
mysql> select SPACE(6); -> " "
REPLACE(A, B, C)
B in string A with
string C.
mysql> select replace("www.tcx.se", "w", "Ww"); -> "WwWwWw.tcx.se"
REPEAT(String, Count)
String Count times. If Count <= 0 returns a
empty string. If String or Count is NULL or
LENGTH(string)*count > max_allowed_size returns NULL.
mysql> select repeat("MySQL", 3); -> "MySQLMySQLMySQL"
REVERSE(String)
mysql> select reverse("abc"); -> "cba"
INSERT(Org, Start, Length, New)
Org starging at Start and
Length long with New. First position in Org is
numbered 1.
mysql> select insert("Quadratic", 3, 4, "What"); -> "QuWhattic"
INTERVAL(N, N1, N2, N3...)
Nn > N3 > N2 > N1 is
this function shall work. This is because a binary search is used (Very
fast). Returns 0 if N < N1, 1 if N < N2 and
so on. All arguments are treated as numbers.
mysql> select INTERVAL(23, 1, 15, 17, 30, 44, 200); -> 3 mysql> select INTERVAL(10, 1, 10, 100, 1000); -> 2 mysql> select INTERVAL(22, 23, 30, 44, 200); -> 0
LCASE(A)
LOWER(A)
A to lower case according to current character set
,dmappings (Default Latin1).
mysql> select lcase("QUADRATICALLY"); -> "quadratically"
UCASE(A)
UPPER(A)
A to upper case.
mysql> select ucase("Hej"); -> "HEJ"
ELT(N, A1, A2, A3...)
A1 if N = 1, A2 if N = 2 and so
on. If N is less than 1 or bigger than the number of arguments
NULL is returned.
mysql> select elt(1, "ej", "Heja", "hej", "foo"); -> "ej" mysql> select elt(4, "ej", "Heja", "hej", "foo"); -> "foo"
FIELD(S, S1, S2, S3...)
S in S1, S2,
S3... list. The complement of ELT().
mysql> select ELT(2, "Hej", "ej", "Heja", "hej", "foo"); -> "ej" mysql> select ELT(-2, "Hej", "ej", "Heja", "hej", "foo"); -> NULL
Some examples using more than one date function:
Select all record with a date_field from the last 30 days.
SELECT something FROM table WHERE NOW() >
FROM_DAYS(TO_DAYS(date_field) + 30);
PERIOD_ADD(P, N)
N months to period P (of type YYMM or
YYYYMM). Returns YYYYMM.
mysql> select PERIOD_ADD(9801,2); -> 199803
PERIOD_DIFF(A, B)
A and B. A and
B should be of format YYMM or YYYYMM.
mysql> select PERIOD_DIFF(9802,199703); -> 11
TO_DAYS(Date)
Date to a daynumber (Number of days since year
0). Date may be a DATE string, a DATETIME string, a
TIMESTAMP([6 | 8 | 14]) or a number of format YYMMDD or
YYYYMMDD.
mysql> select TO_DAYS(9505); -> 733364
mysql> select TO_DAYS('1997-10-07); -> 729669
FROM_DAYS()
mysql> select from_days(729669); -> 1997-10-07
DATE_FORMAT(Date, Format)
Date (a date or a timestamp) according to the
Format string. The following format commands are known:
| M | Month name |
| W | Weekday name |
| D | Day of the month with english suffix |
| Y | Year with 4 digits |
| y | Year with 2 digits |
| m | Month |
| d | Day of the month |
| h | hour |
| i | Minutes |
| s | Seconds |
| w | Day of the week (0=Monday..) |
mysql> select date_format('1997-10-04 22:23:00', "W M Y h:i:s");
-> "Saturday October 1997 22:23:00"
Date (0 = Monday, 1 = Tuesday ..). Date
may be a date string, a datetime string, a timestamp([6 | 8 | 14]) or a
number of format YYMMDD or YYYYMMDD.
mysql> select WEEKDAY('1997-10-04 22:23:00'); -> 5
mysql> select WEEKDAY('1997-11-05'); -> 2
YYYYMMDD or "YYYY-MM-DD"
depending on whether CURDATE() is used in a number or string
context.
mysql> select CURDATE(); -> "1997-12-15" mysql> select CURDATE()+0; -> 19971215
HHMMSS or "HH:MM:SS",
depending on whether CURTIME() is used in a number or string
context.
mysql> select CURTIME(); -> "23:50:20" mysql> select CURTIME()+0; -> 235026
YYYYMMDDHHMMSS or
"YYYY-MM-DD HH:MM:SS" depending on whether NOW() is used
in a number or string context.
mysql> select NOW(); -> "1997-12-15 23:51:26" mysql> select NOW()+0; -> 19971215235131
TIMESTAMP column as an argument in which case it
returns the columns value in seconds. Date may also be a date
string, a datetime string, or a number of format YYMMDD or YYYMMDD in
local time.
mysql> select UNIX_TIMESTAMP(); -> 882226357
mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00'); -> 875996580
YYYY-MM-DD HH:MM:SS or
YYYYMMDDHHMMSS format depending on context (numeric/string).
mysql> select FROM_UNIXTIME(875996580); -> "1997-10-04 22:23:00"
M | Month, textual |
W | Day (of the week), textual |
D | Day (of the month), numeric plus english suffix |
Y | Year, numeric, 4 digits |
y | Year, numeric, 2 digits |
m | Month, numeric |
d | Day (of the month), numeric |
h | Hour, numeric |
i | Minutes, numeric |
s | Seconds, numeric |
w | Day (of the week), numeric |
| All other | All other characters are just copied. |
mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(), "Y D M h:m:s x");
-> "1997 23rd December 03:12:30 x"
H:MM:SS
or HMMSS format depending on context.
mysql> select SEC_TO_TIME(2378); -> "00:39:38" mysql> select SEC_TO_TIME(2378)+0; -> 3938
Time to seconds.
mysql> select TIME_TO_SEC('22:23:00'); -> 80580
mysql> select TIME_TO_SEC('00:39:38'); -> 2378
DATABASE()
mysql> select DATABASE(); -> "test"
USER()
SYSTEM_USER()
SESSION_USER()
mysql> select USER(); -> "davida"
PASSWORD(String)
String. This
must be used to store a password in the 'user' grant table.
mysql> select PASSWORD("badpwd"); -> "7f84554057dd964b"
ENCRYPT(String[, Salt])
String with the unix crypt() command. The
Salt should be a string with 2 characters. If crypt() was
not found NULL will always be returned.
LAST_INSERT_ID()
mysql> select LAST_INSERT_ID(); -> 1
FORMAT(Nr, Num)
Nr to a Format like '#,###,###.##' with Num
decimals.
mysql> select FORMAT(12332.33, 2); -> "12,332.33"
VERSION
mysql> select version(); -> "3.21.16-beta-log"
GROUP BY clause.COUNT(Expr)
NULL rows. count(*) is optimised to
return very quickly if no other column is used in the SELECT.
select count(*) from student; select count(if(length(name)>3,1,NULL)) from student;
AVG(expr)
MIN(expr)
MAX(expr)
min() and max() may take a
string argument and will then return the minimum/maximum string value.
SUM(expr)
STD(expr)
ANSI
SQL.
BIT_OR(expr)
OR of all bits in expr. Caclulation done with 64 bits
precision.
BIT_AND(expr)
AND of all bits in expr. Caclulation done with 64
bits precision.
MySQL has extended the use of GROUP BY. You can use columns or
calculations in the SELECT expressions which doesn't appear in
the GROUP BY part. This stands for 'any possible value for this
group'. By using this, one can get a higher performance by avoiding
sorting and grouping on unnecessary items. For example, in the
following query one doesn't need to sort on b.name:
SELECT a.id,b.name,COUNT(*) from a,b WHERE a.id=b.id GROUP BY a.id
CREATE DATABASE database_name
Creates a database with the given name. The name can only contain letters,
numbers or the '_' character. The max length of the database name is
32 characters.
All databases in MySQL are directories, so a CREATE DATABASE only
creates a directory in the MySQL database directory.
You can also create databases with mysqladmin.
See section 13.1 Overview of the different MySQL programs
DROP DATABASE database_name
Drop all tables in the database and deleted the database.
You have to be VERY carefull with this command!
DROP DATABASE returns how many files was removed from the directory.
Normally this is number of tables*3.
You can also drop databases with mysqladmin.
See section 13.1 Overview of the different MySQL programs
CREATE TABLE table_name ( create_definition,... )
create_definition:
column_name type [DEFAULT default_value] [NOT NULL | NULL] [ PRIMARY KEY ]
[reference_definition]
or PRIMARY KEY ( index_column_name,... )
or KEY [key_name] KEY( index_column_name,...)
or INDEX [index_name] ( index_column_name,...)
or UNIQUE [index_name] ( index_column_name,...)
or FOREIGN KEY index_name ( index_column_name,...) [reference_definition]
or CHECK (expr)
index_column_name:
column_name [ (length) ]
reference_definition:
REFERENCES table_name [( index_column_name,...)]
[ MATCH FULL | MATCH PARTIAL]
[ ON DELETE reference_option]
[ ON UPDATE reference_option]
reference_option:
RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT
The FOREIGN KEY, CHECK and REFERENCE syntax are only for compatibility. They don't actually do anything. See section 5.2 What functionality is missing in MySQL.
If a column doesn't have a DEFAULT value and is not declared as NOT NULL, the default value is NULL.
INT(5) ZEROFILL a value of 5 is retrieved as 00005.
BINARY means that the column will be compared case sensitive. The
default is that all strings are compared case insensitive. BINARY
is 'sticky' which means that if a column marked BINARY is used in
a expression, the whole expression is compared BINARY.
column_name(length) syntax one can specify a index which is only
a part of a string column. This can make the index file much smaller.
BLOB and TEXT types.
isamchk utility to
reorganise tables.
VARCHAR
columns with a length of 1 or 2 are changed to CHAR. When using one
VARCHAR column all CHAR columns longer than 2 are changed to
VARCHAR's.
INSERT/UPDATE all strings (CHAR and
VARCHAR) are silently chopped/padded to the maximal length given
by CREATE. All end spaces are also automatically removed. For example
VARCHAR(10) means that the column can contain strings with a
length up to 10 characters.
NULL value.
REGEXP and RLIKE) uses
ISO8859-1 (Latin1) when deciding the type of a character.
ALTER [IGNORE] TABLE table_name alter_spec [, alter_spec ...]
alter_specification:
ADD [COLUMN] create_definition
or CHANGE [COLUMN] old_column_name create_definition
or ALTER [COLUMN] column_name { SET DEFAULT literal | DROP DEFAULT }
or DROP [COLUMN] column_name
or DROP PRIMARY KEY
or DROP INDEX key_name
or RENAME TABLE AS new_table_name
ALTER TABLE works by creating a temporary table and copying all
information to it and then the old table is deleted and the new one is
renamed. This is done in such a way that all updates are automatically
redirect to the new table without any failed updates. While the
ALTER TABLE is working, the old table is readable for other
clients. Table updates/writes to the table are stalled and only executed
after the new table is ready.
IGNORE isn't specified then the copy will be aborted and
rolled back if there exists any duplicated unique index in the new
table. This is a MySQL extension.
CHANGE column_name, DROP column_name and DROP
INDEX are MySQL extensions to ANSI SQL92.
COLUMN is a pure noise word and can be omitted.
ADD and CHANGE takes the same create_definition as
CREATE TABLE. See section 7.6 CREATE TABLE syntax..
ALTER COLUMN sets a new default value or removes the old
default value for a column.
DROP INDEX removes an index. This is an MySQL extension.
FOREIGN KEY syntax in MySQL exists only for compatibility.
See section 5.2 What functionality is missing in MySQL.
DROP PRIMARY KEY drops index named PRIMARY or if no such
index exists, it drops the first UNIQUE index in the table.
CHANGE tries to convert data to the new format as good as possible.
mysql_info(MYSQL*) one can retrieve how many records were
copied and how many records were deleted because of multiple indexes.
ALTER TABLE one has to have select, insert, delete,
update, create and drop privileges on the table.
ALTER TABLE table_name RENAME AS new_name without any
other options, MySQL will only do a fast rename of table table.
DROP TABLE table_name [, table_name...]
Removes one or more tables. All the data and the definition is removed so take it easy with this command!
DELETE FROM table_name WHERE where_definition
Returns records affected.
If one does a delete without a where clause then the table is recreated which is much faster than doing a delete for each row. In these cases, the SQL command returns zero as affected records.
Using DELETE FROM table_name will work even if the data files do
not exist as only information from the table definition file,
table_name.frm, is used.
mSQL.
SELECT [STRAIGHT_JOIN] [DISTINCT | ALL] select_expression,... [INTO OUTFILE 'file_name' ...] [ FROM table_references [WHERE where_definition ] [GROUP BY column,...] [ ORDER BY column [ASC | DESC] ,..] HAVING where_definition [LIMIT [offset,] rows] [PROCEDURE procedure_name]]
Strings are automatically converted to numbers and numbers to strings
when needed (a-la Perl). If in a compare operation ((=, <>, <= ,<,
>=, >)) either of the arguments are numerical, the arguments are
compared as numbers, else the arguments are compared as strings. All
string comparisons are by default done case-independent by ISO8859-1
(The Scandinavian letter set which also works excellently with English).
select 1 > "6x"; -> 0 select 7 > "6x"; -> 1 select 0 > "x6"; -> 0 select 0 = "x6"; -> 1
HAVING clause.
select concat(last_name,' ',first_name) as name from table order by name
LEFT OUTER JOIN references.
See section 7.11 Join syntax
IFNULL() and IF() returns number or string value according to
use.
ORDER and GROUP columns may be given as column names,
column alias or column numbers in SELECT clauses.
HAVING clause can take any columns or alias in the
select_expressions. It is applied last, just before items are sent to
the client, without any optimisation. Don't use it for items that should
be in the WHERE clause. You can't write (yet):
SELECT user,MAX(salary) FROM users GROUP BY users HAVING max(salary)>10
Change it to:
SELECT user,MAX(salary) AS sum FROM users GROUP BY users HAVING sum > 10
STRAIGHT_JOIN forces the optimiser to join the tables in the same
order that the tables are given in the FROM clause. One can use
this to get a query to be done more quickly if the optimiser joins the
tables in not optimal order. See section 7.17 EXPLAIN syntax. Get information about a SELECT.
MySQL supports the following JOIN syntaxes:
table_reference, table_reference
table_reference [CROSS] JOIN table_reference
table_reference LEFT [OUTER] JOIN table_reference ON conditional-expr
table_reference LEFT [OUTER] JOIN table_reference USING (column-commalist)
table_reference NATURAL LEFT [OUTER] JOIN table_reference
{ oj table_reference LEFT OUTER JOIN table_reference ON conditional-expr }
table_reference AS alias or
table_reference alias.
, and JOIN are semantically identical. This does a full join
between the used tables. One normally specifies in the WHERE
condition how the tables should be linked.
ON conditional is any WHERE conditional. If there is no
matching record in for the right table in a LEFT JOIN a row with all
columns set to NULL will be used for the right table.
USING column-list is a list of fields that must exists in both
tables. A LEFT JOIN B USING (C1,C2,C3...) is defined to be semantically
identical to using a ON expression
A.C1=B.C1 AND A.C2=B.C2 AND A.C3=B.C3... .
NATURAL LEFT JOIN of two tables is defined to be semantically
identical to a USING with all column names that exists in both
tables.
LEFT JOIN syntax is only to be compatible with ODBC.
INSERT INTO table [ (column_name,...) ] VALUES (expression,...) or INSERT INTO table [ (column_name,...) ] SELECT ...
An expression may use any previous column in column_name list (or table if no column name list is given).
The following holds for a multi-row INSERT statement:
ORDER BY clause.
INSERT statement cannot appear in the FROM
clause of the query.
INSERT INTO ... SELECT ... then one can get the following
info string with the C API function mysql_info().
Records: 100 Duplicates: 0 Warnings: 0 Duplicates are number of
rows which couldn't be written because some index would be
duplicated. Warnings are columns which were set to NULL, but have been
declared NOT NULL. These will be set to their default value.
REPLACE INTO table [ (column_name,...) ] VALUES (expression,...) or REPLACE INTO table [ (column_name,...) ] SELECT ...
This works exactly like INSERT, except that if there was some old
record in the table with the same unique index the old record or records
will be deleted before this record is inserted.
See section 7.12 INSERT syntax.
LOAD DATA INFILE 'text_file_name.text' [REPLACE |
IGNORE] INTO TABLE table_name [FIELDS
[TERMINATED BY ',' [OPTIONALLY] ENCLOSED BY '"'
ESCAPED BY '\\' ]] [LINES TERMINATED BY '\n'] [(Field1,
Field2...)]
This is used to read rows from a text file, which must be located on the
server, at a very high speed. The server-client protocol doesn't yet
support files over a connection. If you only have the file on the
client, use rcp or ftp to copy it, possibly compressed, to the server
before using LOAD DATA INFILE. All paths to the text file are
relative to the database directory.
To write data to a text file, use the SELECT ... INTO OUTFILE
'interval.txt' fields terminated by ',' enclosed by '"' escaped by '\\'
lines terminated by '\n' FROM ... syntax.
Normally you don't have to specify any of the text file type options. The
default is a compact text file with columns separated with tab
characters and all rows end with a newline. Tabs, newlines and \
inside fields are prefixed with a \. NULL's are read and written as
\N.
FIELDS TERMINATED BY has the default value of \t.
FIELDS [OPTIONALLY] ENCLOSED BY has the default value of ".
FIELDS ESCAPED BY has the default value of '\\'.
LINES TERMINATED BY has the default value of '\n'.
FIELDS TERMINATED BY and LINES TERMINATED BY may be more
than 1 character.
If LINES TERMINATED BY is an empty string and FIELDS
TERMINATED BY is not empty then lines are also terminated with
FIELDS TERMINATED BY.
If FIELDS TERMINATED BY and FIELDS ENCLOSED BY both are
empty strings (") then this gives a fixed row format ("not delimited"
import format). With a fixed row size NULL values are outputed as a
blank string.
If you specify OPTIONALLY in ENCLOSED BY, then only
strings are enclosed in ENCLOSED BY by the SELECT ... INTO
statement.
Duplicated ENCLOSED BY chars are removed from strings that start
with ENCLOSED BY. For example: With ENCLOSED BY '"':
"The ""BIG"" boss" -> The "BIG" boss The "BIG" boss -> The "BIG" boss
If ESCAPED BY is not empty then the following characters will be
prefixed with the escape character: ESCAPED BY, ASCII 0,
and the first character in any of FIELDS TERMINATED BY,
FIELDS ENCLOSED BY and LINES TERMINATED BY.
If FIELDS ENCLOSED BY is not empty then NULL is read as a
NULL value. If FIELDS ESCAPED BY is not empty then
\N is also read as a NULL value.
If REPLACE is used, then the new row will replace all rows which
have the same unique index. If IGNORE is used, the row will then
be skipped if there already exist a record with an identical unique
index. If none of the above options are used an error will be issued. The
rest of the text file will be ignored if one gets a duplicate index error.
Some possible cases that are not supported by LOAD DATA:
FIELDS TERMINATED BY and FIELDS ENCLOSED
BY both are empty) and BLOB columns.
FIELDS ESCAPED BY is empty and the data contains LINES
TERMINATED BY or FIELDS ENCLOSED BY followed by FIELDS
TERMINATED BY.
All rows are read into the table. If a row has too few columns, the rest of the columns are set to default values.
For security reasons the text file must either reside in the database directory or be readable by all.
For more information about the escaped syntax, See section 7.1 Literals. How do you write strings and numbers?.
When the LOAD DATA query is done, one can get the following info
string with the C API function mysql_info().
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
Warnings are incremented for each column which can't be stored without loss of precision, for each column which didn't get a value from the read text line (happens if the line is too short) and for each line which has more data than can fit into the given columns.
An example that loads all columns:
LOAD DATA INFILE 'persondata.text' INTO TABLE persondata;
See section 11.6 How should I arrange my table to be as fast/small as possible?
UPDATE table SET column=expression,... WHERE where_definition
All updates are done from left to right. If one accesses a column in the expression, update will then use the current value (a given value or the default value) of the column.
UPDATE persondata SET count=count+1
SHOW DATABASES [LIKE wild] or SHOW TABLES [FROM database] [LIKE wild] or SHOW COLUMNS FROM table [FROM database] [LIKE wild] or SHOW INDEXES FROM table [FROM database]
Gives information about databases, tables or columns. If the LIKE
wild part is used the wild string is a normal SQL wildcard (with
% and _). FIELDS may be used as an alias for COLUMNS and
KEYS may be used as an alias for INDEXES.
EXPLAIN SELECT select_options
Gives information about how and in which order tables are joined. With
the help of EXPLAIN one can see when one has to add more indexs
to tables to get a faster select that uses indexs to find the
records. You can also see if the optimiser joins the tables in an
optimal order. One can force the optimiser to use a specific join order
with the STRAIGHT_JOIN option to select.
The different join types are:
system
const
eq_ref
ref
all
Here is a example of a join which is optimized with the help of
EXPLAIN.
EXPLAIN SELECT tt.TicketNumber, tt.TimeIn,
tt.ProjectReference, tt.EstimatedShipDate,
tt.ActualShipDate, tt.ClientID,
tt.ServiceCodes, tt.RepetitiveID,
tt.CurrentProcess, tt.CurrentDPPerson,
tt.RecordVolume, tt.DPPrinted, et.COUNTRY,
et_1.COUNTRY, do.CUSTNAME
FROM tt, et, et AS et_1,
do
WHERE tt.SubmitTime Is Null and tt.ActualPC =
et.EMPLOYID and tt.AssignedPC =
et_1.EMPLOYID and tt.ClientID =
do.CUSTNMBR;
The EXPLAIN returns the following:
table type possible_keys key key_len ref rows Extra
et ALL PRIMARY NULL NULL NULL 74
do ALL PRIMARY NULL NULL NULL 2135
et_1 ALL PRIMARY NULL NULL NULL 74
tt ALL AssignedPC,ClientID,ActualPC NULL NULL NULL 3872
range checked for each record (key map: 35)
In this case MySQL is doing a full join for all tables! This will take quite a long time as the product of the number of rows in each table must be examined!. So if all tables had 1000 records MySQL has to look at 1000^4 = 1000000000000 rows. And if the tables are bigger you can only imagine how long it would take...
In this case the first error is that MySQL can't yet use efficiently indexes on columns that are declared differently: (varchar() and char() are not different in this context)
In this case tt.ActualPC is char(10) and
et.EMPLOYID is char(15).
Fix:
mysql> alter table tt change ActualPC ActualPC varchar(15);
And the above explain shows:
table type possible_keys key key_len ref rows Extra
tt ALL AssignedPC,ClientID,ActualPC NULL NULL NULL 3872
where used
do ALL PRIMARY NULL NULL NULL 2135
range checked for each record (key map: 1)
et_1 ALL PRIMARY NULL NULL NULL 74
range checked for each record (key map: 1)
et eq_ref PRIMARY PRIMARY 15 tt.ActualPC 1
Which is not perfect but much better. This version is executed in a couple of seconds.
After
mysql> alter table tt change AssignedPC AssignedPC varchar(15),
change ClientID Clientid varchar(15);
You get the following from EXPLAIN:
table type possible_keys key key_len ref rows Extra
et ALL PRIMARY NULL NULL NULL 74
tt ref AssignedPC,ClientID,ActualPC ActualPC 15
et.EMPLOYID 52 where used
et_1 eq_ref PRIMARY PRIMARY 15 tt.AssignedPC 1
do eq_ref PRIMARY PRIMARY 15 tt.Clientid 1
Which is 'almost' as good as it can get. The problem is that
MySQL assumes that tt.AcutalPC is evenly distributed which
isn't the case in the tt.
Fortunally it easy to tell MySQL about this:
shell> isamchk -a PATH_TO_MYSQL_DATABASE/tt shell> mysqladmin refresh
And now the join is 'perfect':
table type possible_keys key key_len ref rows Extra
tt ALL AssignedPC,ClientID,ActualPC NULL NULL NULL
3872 where used
et eq_ref PRIMARY PRIMARY 15 tt.ActualPC 1
et_1 eq_ref PRIMARY PRIMARY 15 tt.AssignedPC 1
do eq_ref PRIMARY PRIMARY 15 tt.Clientid 1
(DESCRIBE | DESC) table [column]
Gives information about columns. This command is for Oracle compatibility. See section 7.16 SHOW syntax. Get information about names of columns.. Column may be a column name or a string. Strings may contain wild cards.
LOCK TABLES syntaxLOCK TABLES table_name [AS alias] READ|WRITE [, table_name READ|WRITE] ... UNLOCK TABLES
Locks tables for this thread. Many threads may have a READ lock on the
same table, but one can use a table with a WRITE lock. One can't update
a table on which one has a read LOCK. When one uses LOCK TABLES
one must lock all tables one is going to use!
LOCK TABLES t READ, t as t2 READ SELECT * from t,t2;
All tables are automaticly unlocked when one issues another LOCK
TABLES or if the connection to the server is closed.
SET [OPTION] SQL_VALUE_OPTION=value, ...
The used options remain in effect for the whole current session.
The different options are:
SQL_SELECT_LIMIT=value
SQL_BIG_TABLES= 0 | 1
The table
### is full anymore for big selects that require a big temporary
tables. The default value for a new connection is 0 (use in memory
temporary tables).
SQL_BIG_SELECTS= 0 | 1
WHERE statement. A big query
is defined as a SELECT that will probably have to examine more
than max_join_size rows. The default value for a new connection
is 0 (allow all SELECT's).
SQL_LOG_OFF= 0 | 1
TIMESTAMP= timestamp_value | DEFAULT
LAST_INSERT_ID= #
GRANT (ALL PRIVILEGES | (SELECT, INSERT, UPDATE, DELETE, REFERENCES (column list), USAGE)) ON table TO user,... [WITH GRANT OPTION]
This command doesn't do anything. It is only in MySQL for compatibility reasons. Privileges in MySQL is handled with the mysql grant tables. See section 6.2 How does the privilege system work?
CREATE [UNIQUE] INDEX index_name ON table_name ( column_name,... )
This function doesn't do anything. It is only in MySQL for compatibility reasons. You can create new index with ALTER TABLE. See section 7.7 ALTER TABLE syntax
DROP INDEX index_name
This always succeeds. You can drop an index with ALTER TABLE. See section 7.7 ALTER TABLE syntax
A common problem stems from trying to create a table with column names
timestamp or group, the names of datatypes and functions
built into MySQL. You're allowed to do it (for example,
ABS is an allowed column name), but whitespace is not allowed
between a function name and the '(' when using the functions
whose names are also column names.
The following are explictly reserved words in MySQL. Most of
them (for example) group, are forbidden by ANSI SQL92 as column
and/or table names. A few are because MySQL needs them and is
(currently) using a Yacc parser:
action | add | all | alter
|
and | as | asc | auto_increment
|
between | bigint | bit | binary
|
blob | both | by | cascade
|
char | character | change | check
|
column | columns | create | data
|
database | databases | date | datetime
|
day | day_hour | day_minute | day_second
|
dayofweek | dec | decimal | default
|
delete | desc | describe | distinct
|
double | drop | escaped | enclosed
|
enum | explain | fields | float
|
float4 | float8 | foreign | from
|
for | full | grant | group
|
having | hour | hour_minute | hour_second
|
ignore | in | index | infile
|
insert | int | integer | interval
|
int1 | int2 | int3 | int4
|
int8 | into | is | join
|
key | keys | leading | left
|
like | lines | limit | lock
|
load | long | longblob | longtext
|
match | mediumblob | mediumtext | mediumint
|
middleint | minute | minute_second | month
|
natural | numeric | no | not
|
null | on | option | optionally
|
or | order | outer | outfile
|
partial | precision | primary | procedure
|
privileges | read | real | references
|
rename | regexp | repeat | replace
|
restrict | rlike | select | set
|
show | smallint | sql_big_tables | sql_big_selects
|
sql_select_limit | sql_log_off | straight_join | starting
|
table | tables | terminated | text
|
time | timestamp | tinyblob | tinytext
|
tinyint | trailing | to | use
|
using | unique | unlock | unsigned
|
update | usage | values | varchar
|
varying | varbinary | with | write
|
where | year | year_month | zerofill
|
At TcX, MySQL has worked without any problems in our projects since mid 1996. When released to a wider public we noticed that there were some parts of 'untested code' in MySQL that were quickly found by the new user group who made queries in a different manner. Each new release has had fewer portability problems than the previous one, even though they have all had a lot of new features, and we hope that it will be possible to label one of the next releases 'stable'.
Each release of MySQL has been usable and there has only been problems when users start to use code from 'the gray zones'. Naturally, outside users can't know what the gray zones are and I hope this section will clarify those currently known.
We will here try to answer some of the more important questions that seems to concern a lot of people and clarify some issues. This section has been put together from the information that has come forward in the mailing list which is very active in reporting bugs.
How stable is MySQL? Can I depend on MySQL in this project!
This is about the 3.21.x version of MySQL. All known and reported bugs are fixed in the latest version with the exception of the bugs listed in the BUGS file which are things that are 'design' related.
MySQL is written in multiple layers and different independent modules. Here is a list of the different modules and how tested each of them are.
--skip-locking flag. Known
problems are some Linux systems and SUNOS when using NFS mounted file
systems.
TcX provides email support for paying customers, but the MySQL mailing list usually provides answers to all common questions. Bugs are usually fixed right away with a patch that usually works and for serious bugs there is almost always a new release.
Well, MySQL is evolving quite rapidly here at TcX and we want to share this with other MySQL users. We try to make a release when we have a very useful feature that others seem to have a need for.
We also try to help out users who request features that are easy to implement. We also take note on what our licensed users want to have and we especially take notes on what our extended email supported 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 C MySQL change history.
If there is, by any chance, a fatal bug in a release we will make a new release as soon as possible, that fixes the problem. We would like other companies to do this too :)
The 3.21.x version has had many big changes for portability to a lot of different systems. When the 3.21 release is stable we will remove the alpha/beta suffix and move active development to the 3.22. Bugs will still be fixed in the stable version. We don't believe in a complete freeze, as this also leaves out bug fixes and things that 'must be done'. 'Somewhat freezed' means that we will maybe add small things that 'almost surely will not affect anything thats already working'.
If you are running and old system and want to upgrade, but you don't want to take chances with 3.21 you should upgrade to 3.20.32. I have tried to only fix fatal bugs and small, relatively safe changes in this version.
If you are trying MySQL for the first time or have a little time to test out that your current system, you should use 3.21.
If MySQL crashed (for example if the computer is turned off) when all data is not written to disk the tables may have become corrupted. To check a table use:
isamchk table_name
isamchk -e table_name
isamchk -ei table_name
We at TcX run a cron job on all our important tables once a week.
35 0 * * 0 /path/to/isamchk -s /path/to/dbs/*/*.ISM
This prints out any crashed tables so we can go and examine and repair them when needed.
As we haven't had any unexpected crashed (without hardware trouble) tables for a couple of years now (this is really true), once a week is more than enough of us.
Of course, whenever the machine has done a reboot in the middle of a update one usually has to check all the tables that could have been affected. (This is a 'expected crashed table')
We recommend that to start with one should do a isamchk -s on all
updated tables each night until one gets to trust MySQL as much
as we trust it.
Naturally, one could add a check to safe_mysql that, if there is an old pid file left after a reboot, it should check all tables that have been modified the last 24 hours.
The file format that MySQL uses to store data has been extensively tested, but there is always instances (like a hard kill on the mysqld process in the middle of a write, a hardware error or a unexpected shutdown of the computer) when some tables may be corrupted.
The sign of a corrupted table is usually when queries abort unexpectedly and one gets errors like:
In thess cases you have to repair your tables. The isamchk extern utility can usually detect and fix most things that can go wrong. See section 13.2 The MySQL table check, optimize and repair program.
If you are going to use isamchk on very large files, you should first decide how much memory you want to give to isamchk. More memory gives more speed. For example, if you have more than 32M ram, try:
isamchk -O sortbuffer=16M -O keybuffer=16M -O readbuffer=1M
-O writebuffer=1M ....
shell> mysql database mysql> delete from table_name; mysql> quite
One can always move the MySQL form and data files between
different versions on the same architecture as long as one has the same
base version of MySQL. The current base version is of course
3. If one changes the character set (sort order) by recompiling
MySQL one has to do a isamchk -rq on all tables.
If you already have a version older than 3.20.28 running and want to switch to 3.21.# you have to do the following:
You can start the mysqld 3.21 server with safe_mysqld
--old-protocol to use it with the original 3.20 data. In this case the
new client function, mysql_errno(), will not return any server
error, only CR_UNKNOWN_ERROR, (but it works for client errors)
and the server uses the old password() checking instead of the new one.
If you are NOT using --old-protocol:
scripts/add_long_password must be run to convert the
password field in the 'mysql/user' table to char(16).
MySQL 3.20.28 and above can handle the new user table format without affecting clients. If you have a MySQL version below 3.20.28, passwords will not work on it anymore if you convert the user table. So to be safe, you should first upgrade to at least 3.20.28 and then upgrade to 3.21.#.
The new client code works with a 3.20.# version, so you can use the old 3.20.# server if you experience problems with 3.21.# without having to recompile the clients again.
If you are not using the option --old-protocol to mysqld,
old clients will issue the error message:
ERROR: Protocol mismatch. Server Version = 10 Client Version = 9
mysqld can give error messages in the following languages: Czech,
Dutch, English (default), French, German, Norwegian, Norwegian-ny,
Polish, Portuguese, Spanish and Swedish.
To start mysqld with a language use one of the
--language=lang or -L lang switches:
mysqld --language=swedish
or
mysqld --language=/usr/local/share/swedish
Note that all the language names are in lowercase.
The language files are located in `mysql_base_dir/share/LANGUAGE/'.
By default MySQL will use the ISO8859-1 (Latin1) character set. This is the character set used in the USA and western Europe.
The character set decides what characters are allowed in names and how
things are sorted by the ORDER BY and GROUP BY commands.
You may change this at compile time by the configure switch
--with-charset=charset. See section 4.5.1 Quick installation overview..
When started with the --log-update=file_name switch mysqld
makes a log file with all SQL command that update data. It results in a
file with name of file_name.# where # is a number that is
increased for each reload. If you do not give a file name the current
hostname is used.
The log in smart since it only writes statements that really update
data. So a UPDATE or a DELETE with a where that find no
rows is not written to the log. It even skips UPDATEs that update
a column to the value it had before.
The current limitations of --log-update are:
TIMESTAMP and all other updates with time functions will get the
current date instead of the orignal date.
LAST_INSERT_ID() values should be logged for more safety.
Currently a table is limited to the operation system file size. On Linux the current limit is 2G, on Solaris 2.5.1 the limit is 4G and on Solaris 2.6 the limit is going to be 1000G. To get more that 4G requires some changes to MySQL that are on the Todo. See section E List of thing we want to add to MySQL in the future..
If your big table is going to be read_only, you could use pack_isam (See section 13.3 The MySQL compressed read only table generator) to merge and compress many tables to one. As pack_isam usually compresses a table with at least 50% you can have much bigger tables.
Another solution can be included MERGE library allows one to handle a collection of identical tables as one. Currently MERGE can only be used to scan a collection of tables because it doesn't support indexes. We will add indexes on this in the near future. Identical in this case means that all tables are created with identical column information.
The most general way to do database replication is using the update
log. See section 9.2 The Update log. This requires that one database acts as a master
(all data changes are done here) and one or more others as slaves. To
update a slave just run mysql < update_log.
If you never do deletes you can use timestamps.
It is possible to make a two way updating system using both the update log (for deletes) and timestamps (on both sides). But in that case you must be able to handle confilics when the same data has been changed in both ends. You probably want to keep the old version to help with deciding what has been updated.
Since MySQL tables are stored as files it is easy to do a
backup. To get a consistent backu do a LOCK TABLES on the
relevant tables. See section 7.19 LOCK TABLES syntax. You only need a read lock so other
threads can continue to query the tables. When make a copy of the files
in the database directory. Or if you want to make a sql level backup you
can use SELECT INTO OUTFILE.
Another way is to use the mysqldump script.
mysqldump --tab=some-dir
--lock-tables or simply by copying all table files (.frm, .ISM and
.ISD) away while the server isn't updating anything.
mysqld with --log-update
When you have to restore something (if isamchk -r can't restore
all data as it can in 99.9% of all cases):
The ls in the last command is done to get all log files in the right order
You can also do selective backups with select * into outfile from
table and restore with LOAD DATA FROM INFILE 'file_name' REPLACE
.... To avoid dublicate recods you need a PRIMARY KEY in the
table. The REPLACE means that if there is a 'duplicate index'
conflict when inserting new records the old record will be replaced with
the new one.
You can get the currently used buffer sizes with:
> ./mysqld --help
This should result in a list of all mysqld options and configurable variables like the following.
Possibly variables to option --set-variable (-O) are: back_log current value: 5 join_buffer current value: 131072 key_buffer current value: 1048568 max_allowed_packet current value: 65536 max_connections current value: 90 max_join_size current value: 4294967295 max_sort_length current value: 1024 net_buffer_length current value: 8192 record_buffer current value: 131072 sort_buffer current value: 2097144 table_cache current value: 64 tmp_table_size current value: 1048576 thread_stack current value: 65536
| back_log | How many outstanding connection requests may MySQL have. This comes into play when the main MySQL thread gets VERY many connection requests in a very short time. It when takes some time (but very short) for the main thread to check the connection and start a new thread. The back_log is how many connects can be stacked during this short time before MySQL momentarily stops answering new requests. You only need to increase this is you expext a large number of connections in a short period of time. Or in other words the size of the listen queue for incoming tcp/ip connections. The manual page for the unix system call listen(2) should have more details. Check your OS documentation for the maximum value for this value. |
| join_buffer | This buffer is used for full joins (without indexs). It is allocated one time for each full join between two tables. Increase this to get a faster full join when adding indexes is not possible. Normaly the best way to get fast joins is adding indexes. |
| key_buffer |
Buffers index blocks and is shared by all threads. You might want to
increase this when doing many delete/inserts on a table with lots of
indexs. To get even more speed use LOCK TABLES. See section 7.19 LOCK TABLES syntax.
|
| max_allowed_packet |
Max size of one packet. This allows the message buffer to grow up to
this limit when needed (it is initiated to
net_buffer_length). May be set very big because this is mainly to
find erroneous packets. You must increase this if you are using big
BLOBS. It should be as big as the biggest BLOB you want to use.
|
| max_connections | How many simultaneous clients is allowed. If you increase this you probably has to increase the number of file descriptors mysqld has. This is Operating system depended so look at you OS documentation. |
| max_join_size | Joins that touches more records that this return an error. Set this if you have users to tend to make joins without a where that take a long time and returns millions of rows. |
| max_sort_length |
The number of bytes to use when sorting on BLOB or TEXT
columns.
|
| net_buffer_length | The communication buffer is reset to this size between each query. This should normally not be changed but if you have very little memory you can set it to the expected size of a query. |
| record_buffer | Each thread that is doing a sequential scan allocats a buffer of this size for each table it scans. If you do many sequential scans you may want to increase this. |
| sort_buffer |
Each tread that needs to do a sort allocats a buffer of this
size. Increase this for faster ORDER BY or GROUP BY. A
sort also allocates one or two temporary files. The maximum disk-space
needed is (length_of_what_is_sorted + sizeof(database_pointer)) *
number_of_rows * 2. sizeof(database_pointer) is usally 4 but may
grow in the future for really big tables.
|
| table_cache | Number of open tables for all threads. If this is increased you must see to that the number of open file descriptor is also increased. MySQL need 2 file descriptors for each unique table. |
| tmp_table_size |
If a temporary table gets bigger than this a The table ### is
full error will ge generated. Increase this if you do many advanced
GROUP BY queries.
|
| thread_stack |
How big will each threads C stack be. A lot of the limits
detected by crash-me is dependent on this. The default is normally
enough.
|
> safe_mysqld -O key_buffer=16Mk -O table_cache=128 \
-O sort_buffer=4M -O record_buffer=1M &
If you have little memory with lots of connections, use something like:
> safe_mysqld -O key_buffer=512k -O sort_buffer=100k -O record_buffer=100k &or even
> safe_mysqld -O key_buffer=512k -O sort_buffer=16k -O table_cache=32 \
-O record_buffer=8k -O net_buffer=1K &
Note that if you change a option to mysqld it is only for that
instance. To see the effects of a parameter change do something like
this mysqld -O keybuffer=32m --help.
If there are very many connections, 'swapping problems' may occur if
mysqld has not been configured to use very little memory for each
connection. It also works nice if you have a enough memory for all
connections of course.
For example, for 200 open connections one should have a table cache of
at least 200 * (max_number of tables in join).
net_buffer_length).
mysqld one can specify a key buffer. This will buffer
all indexs in all tables at FIFO basis (variable keybuffer).
BLOBs are stored on disk. One current
problem is that if the HEAP table exceeds the size of
tmp_table_size, one will get the error: 'The table ### is full'.
In the future we will fix this by automatically changing the in memory
(HEAP) table to a disk based (NISAM) table if needed. To go around this
problem one can increase the -O tmp_table_size=# option to mysqld
or use the SQL option SQL_BIG_TABLES. See section 7.20 SET OPTION syntax.. In
MySQL 3.20 the maximum size of the temporary table was
recordbuffer*16, so if you are using this version you have to
increase recordbuffer. There also exists a patch to always store
temporary tables on disk, but this will affect the speed of all
complicated queries.
mysqladmin refresh closes all tables that are not used and marks all
used tables to be closed when the running thread finishes. This will
effectively free most used memory.
When running mysqld ps, other programs may report that is takes a lot of
memory. This may be caused by thread-stacks on different memory
addresses. For example, the Solaris ps calculates the unused memory
between stacks as used memory. You can verify this by checking available
swap with 'swap -s'. We have tested mysqld with commercial memory-leakage
detectors so there should not be any memory leaks.
All indexs, PRIMARY, UNIQUE and INDEX(), are stored in B trees. Strings are automatically prefix- and end-space compressed.
INDEX(col1, col2) creates a multiple index over the two columns. The index can be seen like a concatenation of the given columns. If you use INDEX(col1), INDEX(col2) instead of INDEX(col1,col2) you get two separate indexs instead.
SELECT * FROM table WHERE col1=# AND col2=#
In a case of INDEX(col1,col2) the right row(s) can be fetched directly. In a case of INDEX(col1), INDEX(col2) the optimiser decides which index will find fewer rows and this index will be used to fetch the rows.
If the table has an index INDEX(col1,col2,col3...) the prefix of this can be used by the optimiser to find the rows. This means that the above gives you search capabilities on: INDEX(col1) and INDEX(col1,col2) and INDEX(col1,col2,col3)...
MySQL can't use a sub part of a index to locate rows through a index.
With the definition INDEX(col1,col2,col3):
SELECT * FROM table WHERE col1=# SELECT * FROM table WHERE col2=# SELECT * FROM table WHERE col2=# and col3=#
only the first query will use indexs.
(Incomplete, MySQL does a lot of optimisations.)
The first issue about getting a slow SELECT ... WHERE faster is
to check if one could add a index to make it faster. All references
between different tables should usually be done with indexs. One can use
the EXPLAIN command to check which indexes are used in a
select. See section 7.17 EXPLAIN syntax. Get information about a SELECT.. See section 11.3 How does MySQL use indexs?
((a AND b) AND c OR
(((a AND b) AND (c AND d)))) -> (a AND b) OR (a AND b AND c AND d)
(a<b AND b=c) AND a=5 -> b>5 AND b=c A=5
(b>=5
AND b=5) OR (b=6 and 5=5) or (B=7 and 5=6) -> B=5 or B=6
=, >, >=, <,
<=, BETWEEN and a LIKE with a character prefix like
'something%'.
AND levels.
index = 1 or A = 10 -> NULL (can't use index.)
index = 1 or A = 10 and index=2 -> index = 1 OR index = 2
index_part_1 = const and index_part_3 = const -> index_part_1 =
const
const_table.index = constant
const_table.index_part_1 = const_table2.column and const_table.index_part_2 = constant
ORDER BY and in GROUP
comes from the same table, then this table is preferred first when joining.
The cache of open tables can grow to a maximum of table-cache
(default 64, changeable with -O table_cache=#).
A table is never closed, except when the cache is full and another thread
tries to open a table or if one uses 'mysqladmin refresh'.
When the limit is reached, MySQL closes as many tables as possible, until the cache size has been reached or there are no more unused tables. This means that if all tables are in use by some threads, there will be more open tables than the cache limit, but the extra tables will be closed eventually. Tables are closed according to last-used order.
A table is opened (again) for each concurrent access. This means that if one has two threads running on the same table or access the table twice in the same query (with AS) the table needs to be opened twice. The first open of any table takes 2 file descriptors, each following use of the table takes only one file descriptor.
Each table is actually 3 files. If you have many files in a directory open, close and create will be slow. If you also do selects on many different tables there will be a little overhead because when the table cache is full for every table that has to be opened another has to be closed. One can make the overhead smaller by making the table cache larger.
NOT NULL if possible. It makes everything faster and you save 1
bit per column.
MEDIUMINT is often better than INT.
VARCHAR columns, a fixed size record format
will be used. This is much faster but may unfortunately waste some
space. See section 11.10 What are the different row formats? Or when to use VARCHAR/CHAR?.
isamchk -a on the
table once it is loaded with relevant data. This updates a value for each
index that tells how many rows that have the same value for this index in
average. Of course, this is always 1 for unique indexes.
isamchk -Sir1
(if you want so sort on index 1). If you have a unique index that you want
to read all records from in numeric order this is a good way to make
that faster.
LOAD DATA FROM INFILE. This is
usually 20 times faster than using a lot of INSERTs. If the text file
isn't on the server, rcp it to the server first. See section 7.14 LOAD DATA INFILE syntax.
You can even get more speed when loading data to tables with many indexs
by doing:
mysqladmin refresh.
isamchk -k0 database/table_name. This will remove all use of indexs
from the table.
LOAD DATA INFILE....
isamchk -rq database/table_name.
mysqladmin refresh.
LOAD DATA FROM INFILE and INSERT is to enlarge the key buffer.
This can be done with the -O key_buffer=# option to (safe)mysqld.
For example 16M should be a good value if you have much RAM :)
SELECT ... INTO OUTFILE. See section 7.14 LOAD DATA INFILE syntax.
LOCK TABLES on the tables. ...FROM INFILE... and
...INTO OUTFILE... are atomic so you don't have to use
LOCK TABLES when using these. See section 7.19 LOCK TABLES syntax.
To check how you are doing, run isamchk -evi on the .ISM
file.
The time to insert a record consists of:
Where (number) is proportional time. This does not take into calculation the initial overhead to open tables (which is done once for each simultaneous running query).
The size of the table slows down the insert of indexs with N log N (B-trees).
A way of speeding ut inserts in to lock your table during the inserts.
LOCK TABLES a WRITE; INSERT INTO a VALUES (1,23) INSERT INTO a VALUES (2,34) INSERT INTO a VALUES (4,33) INSERT INTO a VALUES (8,26) INSERT INTO a VALUES (6,29) UNLOCK TABLES;
The main speed difference is that the index buffer is only flushed once to disk for all inserts. Normally there would be as many index buffer flushes as there are inserts.
Locking will also lower the total time of multi-connection test but the maximum wait time for some threads will go up.
For example:
thread 1 does 1000 inserts thread 2, 3, and 4 does 1 insert thread 5 does 1000 inserts
If you don't use locking, 2, 3 and 4 will finish before 1 and 5. If you use locking 2,3,4 may finnish before 1 or 5 but probably not, but the total time should be about 40 % faster.
As INSERTS, UPDATES and DELETES are very fast in
MySQL one will get better overall performance by adding locks
around everything that does more than about 5 inserts/updates in a row.
If one does very many inserts in a row one could do a UNLOCK
TABLES followed by a LOCK TABLES once in a while (about each
1000 rows) to give other threads access to the table. This would still
give a nice performance gain.
Of course LOAD DATA INFILE is much faster still.
The delete time of a record is exactly proportional to the number of indexs. To increase the speed of deletes you can increase the size of the index cache. The default index cache is 1M and to get faster deletes it should be increased a couple of times (try 16M if you have enough memory).
mysqld with the right options. More memory gives more speed
if you have it. See section 11.1 How does one change the size of MySQL buffers?.
SELECT's faster. See section 11.3 How does MySQL use indexs?
NOT NULL on all columns.
See section 11.6 How should I arrange my table to be as fast/small as possible?
--skip-locking disables file locking between SQL requests. This gives a greater speed
but has the following consequences:
mysqladmin refresh before
one tries to check/repair tables with isamchk. (isamchk -d
table_name is always allowed).
--skip-locking is default when compiling with MIT threads.
This is because flock() isn't fully support by MIT threads on all
platforms.
Actually using no VARCHAR or BLOB types results in a fixed row
size. Otherwise CHAR and VARCHAR are the same.
You can check the format used in a table with isamchk -d.
MySQL has three different table formats:
VARCHAR, TEXT
or BLOB type in a table.
isamchk -r should be run now and then to
reorganise the table. This is to get a better layout. Use isamchk -ei
table_name for some statistics.
isamchk
-ed. All links may be removed with isamchk -r.
When you run mysqladmin status you get something like:
Uptime: 426 Running threads: 1 Questions: 11082 Reloads: 1 Open tables: 12
This can be somewhat perplexing if you only have 6 tables.
As MySQL is multithreaded it may have many queries on the same table at once. To minimise the problem with two threads having different states on the same file, I open the table again for each concurrent thread. This takes some memory and one extra file descriptor for the data file. The index file descriptor is shared all threads.
This should contains a technical describtion of the MySQL benchmark suite (and crash-me) but that describtion is not written yet. Currently see the code and results in `bench' directory in the distribution. And of course on the web page.
It is meant to be a benchmark that will tell any user what things a given SQL implementation is good or bad at.
crash-me tries to find what a database supports by actually running queries. It find for example:
All MySQL clients that communicate with the server useing the
mysqlclient library use the following environment variables:
| Name | Description |
| MYSQL_UNIX_PORT | The default socket. Used with 'localhost'. |
| MYSQL_TCP_PORT | The default TCP port. |
| MYSQL_PWD | The default password. |
mysql
mysqlaccess
mysqladmin
mysqld
mysqldump
mysqlimport
LOAD DATA INFILE. See section 7.14 LOAD DATA INFILE syntax
mysqlshow
mysqlbug
mysql_install_db
isamchk
make_binary_release
msql2mysql
mSQL program to
MySQL. Doesn't handle all cases but gives a good start when
converting.
replace
replace a
b b a -- files swaps a and b in the given files.
safe_mysqld
For information about how to use isamchk to repair a crashed table: See section 8.4 How to repair tables..
isamchk doesn't use any more memory than you allow it to use with
the -O options. The default is to use only about 2M to fix
things.
But isamchk uses temporary files in TMPDIR. If
TMPDIR points to a memory file system you mey easily get out of
memory errors.
Using -O sortbuffer=16M should probably be enough for most cases.
To get a description/statistics from a table use the forms below. We will explain some of the information in more detail later.
isamchk -d table_name
--skip-locking
isamchk may report an error for a table that is updated while
isamchk runs, but there isn't any risk of destroying data.
isamchk -d -v table_name
isamchk -eis table_name
isamchk -eiv table_name
Example of isamchk -d output:
ISAM file: company.ISM
Data records: 1403698 Deleted blocks: 0
Recordlength: 226
Record format: Fixed length
table description:
Key Start Len Index Type
1 2 8 unique double
2 15 10 multip. text packed stripped
3 219 8 multip. double
4 63 10 multip. text packed stripped
5 167 2 multip. unsigned short
6 177 4 multip. unsigned long
7 155 4 multip. text
8 138 4 multip. unsigned long
9 177 4 multip. unsigned long
193 1 text
Example of isamchk -d -v output:
ISAM file: company.ISM
Isam-version: 2
Creation time: 1996-08-28 11:44:22
Recover time: 1997-01-12 18:35:29
Data records: 1403698 Deleted blocks: 0
Datafile: Parts: 1403698 Deleted data: 0
Datafilepointer (bytes): 3 Keyfile pointer (bytes): 3
Max datafile length: 3791650815 Max keyfile length: 4294967294
Recordlength: 226
Record format: Fixed length
r
table description:
Key Start Len Index Type Root Blocksize Rec/key
1 2 8 unique double 15845376 1024 1
2 15 10 multip. text packed stripped 25062400 1024 2
3 219 8 multip. double 40907776 1024 73
4 63 10 multip. text packed stripped 48097280 1024 5
5 167 2 multip. unsigned short 55200768 1024 4840
6 177 4 multip. unsigned long 65145856 1024 1346
7 155 4 multip. text 75090944 1024 4995
8 138 4 multip. unsigned long 85036032 1024 87
9 177 4 multip. unsigned long 96481280 1024 178
193 1 text
Example of isamchk -eis output:
Checking ISAM file: company.ISM Key: 1: Keyblocks used: 97% Packed: 0% Max levels: 4 Key: 2: Keyblocks used: 98% Packed: 50% Max levels: 4 Key: 3: Keyblocks used: 97% Packed: 0% Max levels: 4 Key: 4: Keyblocks used: 99% Packed: 60% Max levels: 3 Key: 5: Keyblocks used: 99% Packed: 0% Max levels: 3 Key: 6: Keyblocks used: 99% Packed: 0% Max levels: 3 Key: 7: Keyblocks used: 99% Packed: 0% Max levels: 3 Key: 8: Keyblocks used: 99% Packed: 0% Max levels: 3 Key: 9: Keyblocks used: 98% Packed: 0% Max levels: 4 Total: Keyblocks used: 98% Packed: 17% Records: 1403698 M.recordlength: 226 Packed: 0% Recordspace used: 100% Empty space: 0% Blocks/Record: 1.00 Recordblocks: 1403698 Deleteblocks: 0 Recorddata: 317235748 Deleted data: 0 Lost space: 0 Linkdata: 0 User time 1626.51, System time 232.36 Maximum resident set size 0, Integral resident set size 0 Non physical pagefaults 0, Physical pagefaults 627, Swaps 0 Blocks in 0 out 0, Messages in 0 out 0, Signals 0 Voluntary contexts switches 639, Involuntary contexts switches 28966
Example of isamchk -eiv output:
Checking ISAM file: company.ISM Data records: 1403698 Deleted blocks: 0 - check file-size - check delete-chain index 1: index 2: index 3: index 4: index 5: index 6: index 7: index 8: index 9: No recordlinks - check index reference - check data record references index: 1 Key: 1: Keyblocks used: 97% Packed: 0% Max levels: 4 - check data record references index: 2 Key: 2: Keyblocks used: 98% Packed: 50% Max levels: 4 - check data record references index: 3 Key: 3: Keyblocks used: 97% Packed: 0% Max levels: 4 - check data record references index: 4 Key: 4: Keyblocks used: 99% Packed: 60% Max levels: 3 - check data record references index: 5 Key: 5: Keyblocks used: 99% Packed: 0% Max levels: 3 - check data record references index: 6 Key: 6: Keyblocks used: 99% Packed: 0% Max levels: 3 - check data record references index: 7 Key: 7: Keyblocks used: 99% Packed: 0% Max levels: 3 - check data record references index: 8 Key: 8: Keyblocks used: 99% Packed: 0% Max levels: 3 - check data record references index: 9 Key: 9: Keyblocks used: 98% Packed: 0% Max levels: 4 Total: Keyblocks used: 9% Packed: 17% - check records and index references [LOTS OF ROW NUMBERS DELETED] Records: 1403698 M.recordlength: 226 Packed: 0% Recordspace used: 100% Empty space: 0% Blocks/Record: 1.00 Recordblocks: 1403698 Deleteblocks: 0 Recorddata: 317235748 Deleted data: 0 Lost space: 0 Linkdata: 0 User time 1639.63, System time 251.61 Maximum resident set size 0, Integral resident set size 0 Non physical pagefaults 0, Physical pagefaults 10580, Swaps 0 Blocks in 4 out 0, Messages in 0 out 0, Signals 0 Voluntary contexts switches 10604, Involuntary contexts switches 122798
Here is the data file sizes of the table used above.
-rw-rw-r-- 1 monty tcx 317235748 Jan 12 17:30 company.ISD -rw-rw-r-- 1 davida tcx 96482304 Jan 12 18:35 company.ISM
Explanations for the things isamchk prints:
ISAM file
Isam-version
Creation time
Recover time
Data records
Deleted blocks
Datafile: Parts
Data
records.
Deleted data
Datafile pointer
Keyfile pointer
Max datafile length
.ISD) get.
Max keyfile length
.ISM) get.
Recordlength
Record format
Fixed
length.
table description
Key
Start
Len
Index
unique or multip.. If one value can exist multiple times
in this index.
Type
C data-type
with the options packed, stripped or empty.
Root
Blocksize
Rec/key
isamchk -a. If this is not updated at all, a default
value of 30 is given.
Keyblocks used
Packed
CHAR/VARCHAR/DECIMAL keys. For long strings like
names, this can significantly reduce the space used. In the above example
the 4 key is 10 characters long and gets a 60% reduction in space.
Max levels
Records
M.recordlength
Packed
Recordspace used
Empty space
Blocks/Record
isamchk. See section 8.4 How to repair tables..
Recordblocks
Deleteblocks
Recorddata
Deleted data
Lost space
Linkdata
pack_isam is an extra that you get when ordering more that 10
licenses or extended support. Since pack_isam is distributed
binary only, pack_isam is only available on some platforms.
Of course, all future updates to pack_isam is included in the
price. pack_isam may at some time be included as standard when
we get some kind of turnover for MySQL.
pack_isam works by compressing each column in the table
separately. The information needed to decompress is read into memory
when the table is opened. This gives a much better performance when
accessing individual records as one only has to uncompress exactly one
record, not a much larger disk block like when using stacker on MSDOS.
MySQL uses memory mapping (mmap) on compressed tables and falls back to normal read/write file usage if mmap did not work.
Usually, pack_isam packs the datafile 40-70%.
There is currently two limitations with pack_isam:
Fixing these limitations is on our TODO but with low priority.
pack_isam options:
> pack_isam --help
pack_isam Ver 5.0 for SOLARIS 2.5 on SPARCstation
Copyright (C) 1994-1997 TcX AB & Monty Program KB & Detron HB.
This is not free software. You must have a license to use this program
This software comes with ABSOLUTELY NO WARRANTY
Pack a ISAM-database to take much smaller space
Keys are not updated, one must run isamchk -rq on datafile afterwards
Usage: pack_isam [OPTIONS]
-b, --backup Make a backup of the table as table_name.OLD
-f, --force Force packing of table even if it's gets bigger or
tempfile exists.
-j, --join=# Join all given tables into table.
All tables MUST be identical.
-p, --packlength=# Force storage size of recordlength (1,2 or 3)
-s, --silent Be more silent.
-t, --test Don't pack table only test packing it
-v, --verbose Write info about progress and packing result
-w, --wait Wait and retry if table is in use
-T, --tmp_dir=# Use temporary directory to store temporary table
-#, --debug=... output debug log. Often this is 'd:t:o,filename`
-?, --help display this help and exit
-V, --version output version information and exit
Typical run:
(/my/monty/tmp) ls -l station.*
-rw-rw-r-- 1 monty my 994128 Apr 17 19:00 station.ISD
-rw-rw-r-- 1 monty my 53248 Apr 17 19:00 station.ISM
-rw-rw-r-- 1 monty my 5767 Apr 17 19:00 station.frm
(/my/monty/tmp) isamchk -dvv station
ISAM file: station
Isam-version: 2
Creation time: 1996-03-13 10:08:58
Recover time: 1997-02-02 3:06:43
Data records: 1192 Deleted blocks: 0
Datafile: Parts: 1192 Deleted data: 0
Datafilepointer (bytes): 2 Keyfile pointer (bytes): 2
Max datafile length: 54657023 Max keyfile length: 33554431
Recordlength: 834
Record format: Fixed length
table description:
Key Start Len Index Type Root Blocksize Rec/key
1 2 4 unique unsigned long 1024 1024 1
2 32 30 multip. text 10240 1024 1
column Start Length Type
1 1 1
2 2 4
3 6 4
4 10 1
5 11 20
6 31 1
7 32 30
8 62 35
9 97 35
10 132 35
11 167 4
12 171 16
13 187 35
14 222 4
15 226 16
16 242 20
17 262 20
18 282 20
19 302 30
20 332 4
21 336 4
22 340 1
23 341 8
24 349 8
25 357 8
26 365 2
27 367 2
28 369 4
29 373 4
30 377 1
31 378 2
32 380 8
33 388 4
34 392 4
35 396 4
36 400 4
37 404 1
38 405 4
39 409 4
40 413 4
41 417 4
42 421 4
43 425 4
44 429 20
45 449 30
46 479 1
47 480 1
48 481 79
49 560 79
50 639 79
51 718 79
52 797 8
53 805 1
54 806 1
55 807 20
56 827 4
57 831 4
Compressing station.ISD: (1192 records)
- Calculating statistics
normal: 20 empty-space: 16 empty-zero: 12 empty-fill: 11
pre-space: 0 end-space: 12 intervall-fields: 5 zero: 7
Original trees: 57 After join: 17
- Compressing file
87.14%
(/my/monty/tmp) ls -l station.*
-rw-rw-r-- 1 monty my 127874 Apr 17 19:00 station.ISD
-rw-rw-r-- 1 monty my 55296 Apr 17 19:04 station.ISM
-rw-rw-r-- 1 monty my 5767 Apr 17 19:00 station.frm
(my/monty/tmp) isamchk -dvv station
ISAM file: station
Isam-version: 2
Creation time: 1996-03-13 10:08:58
Recover time: 1997-04-17 19:04:26
Data records: 1192 Deleted blocks: 0
Datafile: Parts: 1192 Deleted data: 0
Datafilepointer (bytes): 3 Keyfile pointer (bytes): 1
Max datafile length: 16777215 Max keyfile length: 131071
Recordlength: 834
Record format: Compressed
table description:
Key Start Len Index Type Root Blocksize Rec/key
1 2 4 unique unsigned long 10240 1024 1
2 32 30 multip. text 54272 1024 1
Field Start Length Type Huff tree Bits
1 1 1 constant 1 0
2 2 4 zerofill(1) 2 9
3 6 4 no zeros, zerofill(1) 2 9
4 10 1 3 9
5 11 20 table-lockup 4 0
6 31 1 3 9
7 32 30 no endspace, not_always 5 9
8 62 35 no endspace, not_always, no empty 6 9
9 97 35 no empty 7 9
10 132 35 no endspace, not_always, no empty 6 9
11 167 4 zerofill(1) 2 9
12 171 16 no endspace, not_always, no empty 5 9
13 187 35 no endspace, not_always, no empty 6 9
14 222 4 zerofill(1) 2 9
15 226 16 no endspace, not_always, no empty 5 9
16 242 20 no endspace, not_always 8 9
17 262 20 no endspace, no empty 8 9
18 282 20 no endspace, no empty 5 9
19 302 30 no endspace, no empty 6 9
20 332 4 allways zero 2 9
21 336 4 allways zero 2 9
22 340 1 3 9
23 341 8 table-lockup 9 0
24 349 8 table-lockup 10 0
25 357 8 allways zero 2 9
26 365 2 2 9
27 367 2 no zeros, zerofill(1) 2 9
28 369 4 no zeros, zerofill(1) 2 9
29 373 4 table-lockup 11 0
30 377 1 3 9
31 378 2 no zeros, zerofill(1) 2 9
32 380 8 no zeros 2 9
33 388 4 allways zero 2 9
34 392 4 table-lockup 12 0
35 396 4 no zeros, zerofill(1) 13 9
36 400 4 no zeros, zerofill(1) 2 9
37 404 1 2 9
38 405 4 no zeros 2 9
39 409 4 allways zero 2 9
40 413 4 no zeros 2 9
41 417 4 allways zero 2 9
42 421 4 no zeros 2 9
43 425 4 allways zero 2 9
44 429 20 no empty 3 9
45 449 30 no empty 3 9
46 479 1 14 4
47 480 1 14 4
48 481 79 no endspace, no empty 15 9
49 560 79 no empty 2 9
50 639 79 no empty 2 9
51 718 79 no endspace 16 9
52 797 8 no empty 2 9
53 805 1 17 1
54 806 1 3 9
55 807 20 no empty 3 9
56 827 4 no zeros, zerofill(2) 2 9
57 831 4 no zeros, zerofill(1) 2 9
If you need it as sql function (like SOUNDEX()), its real easy:
sql_lex.cc defining the function name in the
sql_functions array.
sql_yacc.y. On defines the preprocessor symbol
yacc can define (this should be added at the beginning of the
file). Then define the function parameters and create an 'item' with
these parameters. Check, for example, all occurrences of SOUNDEX in
sql_yacc.y
double *Item_func_newname::val() If
you are defining a number function or String
*Item_func_newname::Str(String *str) if you are defining a string
function.
void
Item_func_newname::fix_length_and_dec() This should at least calcutate
max_length based on the given arguments. max_length is the
maximal number of chars the function may return. If the function can't
return a NULL, one should set maybe_null = 0.
About string functions:
String *str argument provides a string
buffer that may be used to hold the result.
MySQL ODBC is a 32 bit ODBC (2.50) level 0 driver for Windows95 and NT. We hope somebody will port it to Windows 3.x.
We have only tested ODBC with Admndemo, some C programs, Msquery and Excel.
To give some light about any problem we would like to have the log file from the ODBC manager (the log you get when requesting logs from ODBCADMIN) and a MYODBC log.
To get a MYODBC log, please put this MYSQL_DEBUG=d:t:O,filename
in your `AUTOEXEC.BAT' and restart.
The log will be written to file `filename'.
Most programs should work with MyODBC, but these we tested ourselves or got a confirmation from some user that is works:
SELECT concat(sunrise_time), concat(sunset_time) FROM sunrise_sunset;Values returned in this format (string) should be correctly recognised by Excel97 as time values. What
concat() does in this case is that it fools ODBC to think
the column is of 'string type'. Without the 'concat()' ODBC knows the
column is of time type. And Exel does not understand that.
Note that this is uses bug in Excel because it automaticly converts a
string to a time. This would be great if the source was a text file, but
this is plain stupid when the source is a ODBC connection which reports
exact types for each column.
There are three possibilities for specifying the server name on windows95:
ip hostname
For example:
194.216.84.21 my
Example of how to fill in the 'ODBC setup'.
Data Source Name: test Description: This is my test database Server: 194.216.84.21 User: monty Password: my Port:
These are default values to be given when prompting for a Driver connect. You don't have to give 'server', 'user' or 'password' in this screen. If port is not given the default port (3333) is used.
When connection to a ODBC source you have the option to change the server, user, password and port.
A common problem is how to get the value of a automatically generated id from a insert. With ODBC you can do something like this:
INSERT INTO foo (auto,text) VALUES(NULL,'text') select LAST_INSERT_ID()
or if you are just going to insert in into another table:a
INSERT INTO foo (auto,text) VALUES(NULL,'text') INSERT INTO foo2 (id,text) VALUES(LAST_INSERT_ID(),'text')
MySQL server has gone away error.
The most common reason for the MySQL server has gone away error
is that the server closed the connection because of a timeout. By
default the server closes the connection after 8 hours if nothing has
happended.
If you have a script you just have to reconnect and try again. If you
are using the mysql monitor just type reconnect.
If you do a query and get something like the following error:
mysql: Out of memory at line 42, 'malloc.c' mysql: neaded 8136 byte (8k), memory in use: 12481367 bytes (12189k)) ERROR 2008: MySQL client got out of memory
Note that the error says the the MySQL client. The reason for this error is simply that the client does not have enough memory to store the whole result.
When the client gets a block bigger that net_buffer_length it
issues a Packet to large error.
If the mysql client is used you may set a bigger buffer by
starting the client with mysql --set-variable=
net_buffer_length=1m.
This error occurs when a in memory temporary table gets bigger than
tmp_table_size. To avoid this problem one can increase the
-O tmp_table_size=# option to mysqld or use the SQL option
SQL_BIG_TABLES. See section 7.20 SET OPTION syntax..
On a disk full condition MySQL does the following:
mysqladmin kill to the thread and
free enough space for 1 row!
Access denied? error.
See section 6.2 How does the privilege system work?. And especially See section 6.7 Why do I get this Access denied? error..
mysqld (the MySQL server) can run as any user. In order to change mysqld to run as user USER, you'd have to the following:
shell> chown -R USER /your/path/to/mysql/var
You don't have to do anything to safe_mysqld to run as not root.
At this point, your mysqld process would be running fine and dandy as user 'USER'. One thing hasn't changed though - the access permissions. By default (right after running the permissions table install script), only user 'root' has access permission to the database. Unless you have changed that, it's still true. This shouldn't stop you from accessing MySQL when you're logged in under a user other than root, just specify -u root to the client program. Note that accessing MySQL as root, by supplying -u root in the command line, doesn't have ANYTHING to do with MySQL running as root, as a user or as anyone else. The access permissions and userbase of MySQL are completely separate from the UNIX users. The only connection to the UNIX users is if you don't use the -u option to clients. In this case the client will try to login into MySQL with your UNIX login name. If your UNIX box itself isn't secured, you should probably at least put a password on the root users in the MySQL access tables, since any johndoe user can run 'mysql -u root dbname' and do whatever he likes.
If you have problems with file permissions, for example when creating a table mysql gives: "ERROR: Can't find file: 'path/with/filename.frm' (Errcode: 13)", then you might have the wrong value for environment variable UMASK. Default umask is 0664. Fix:
UMASK=432 export UMASK ./bin/safe_mysqld
The format of DATE is 'YYYY-MM-DD'. Actually nothing else is allowed (ANSI SQL). One should use this format to update or in the WHERE clause, ie select * from table_1 where idate >= '1997-05-05';
As a convenience, MySQL automatically converts the date to a
number if used in a number context. It is also smart enough to allow a
'relaxed' string form when updating and in a WHERE with a compare
to a TIMESTAMP, DATE or a DATETIME column.
This means that the following works:
insert into table_1 (idate) values (19970505) ;
insert into table_1 (idate) values ('19970505') ;
insert into table_1 (idate) values ('1997-05-05');
insert into table_1 (idate) values ('1997.05.05');
insert into table_1 (idate) values ('1997 05 05');
select idate from table_1 where idate >= '1997-05-05';
select idate from table_1 where idate >= 19970505;
select mod(idate,100)1 from table_1 where idate >= 19970505;
select idate from table_1 where idate >= '19970505';
The following will not work:
select idate from table_1 where strcmp(idate,'19970505')=0; Because '19970505' is compared as a string to '1997-05-05'.
By default a MySQL column is case insensitive (There are some
character sets that never are case insensitive). That means that if you
search with column like 'a%'; you will get all columns that start
with A or a. If you want to make this search case
sensitive use something like INDEX(column, "A")=0 to check a
prefix. Or STRCMP(column, "A") = 0 if the whole string should be
the same.
If you want column to always be treated in a case sensitive maner
declare it as BINARY. See section 7.6 CREATE TABLE syntax..
If you are using Chinese data in the so-called big5 encoding you want to
make all character columns BINARY. This works because the sorting
order of big5 encoding characters is based on the order of ascii codes.
The C API is distributed with MySQL. It is included in
the libmysqlclinet library.It allows C programs to access
a database.
Most of the other client APIs (all except JAVA) use this library to connect. So for example ypu can use the same environment variables.
The client has a max communication buffer size. This is automatically increase up to the maximum size (the default for this is 512kb). As buffers are increased (but not decreased until close) on demand, it will not take any resources if one increases this. This size check is mostly a check for erroneous queries and communication packets.
The commncation buffer must be big enough to contain a single SQL statement and one row of returned data (but of course not at the same time). Each threads communication buffer is dynamicly enlarged to handle any row or query up to the imposed limit.
So if you have BLOBs that contains data up to 16M you must have
at least 16M as your communication buffer limit. See section 11.1 How does one change the size of MySQL buffers?.
MySQL shrinks each communication buffer to net_buffer_length
after each query.
| mysql_affected_rows | Retrieves the number of affected rows by the last UPDATE, DELETE or INSERT. |
| mysql_close | Closes a server connection. |
| mysql_connect | Establish a connection to a MySQL server. |
| mysql_create_db | Create a database. |
| mysql_data_seek | Seeks to an arbitrary row in a query result set. |
| mysql_drop_db | Drop a database. |
| mysql_eof | Determine if last row has been read. |
| mysql_error | The error message from last MySQL function. |
| mysql_fetch_field | Find out what type a table field is. |
| mysql_fetch_lengths | Returns the length of all columns in a query result set. |
| mysql_fetch_row | Fetch the 'next' row in the query result. |
| mysql_field_seek | Put the column cursor on column number field. |
| mysql_free_result | Free memory used to store a query result. |
| mysql_get_client_info | Return version information for the current client library. |
| mysql_get_host_info | Returns name of server host. |
| mysql_get_proto_info | Get protocol version used by connection. |
| mysql_get_server_info | Returns the version number of the server. |
| mysql_insert_id | Returns ID generated for a AUTO_INCREMENT field. |
| mysql_list_dbs | Return maching database names. |
| mysql_list_fields | Return maching field names. |
| mysql_list_processes | Get a list of the current server threads. |
| mysql_list_tables | Return maching table names. |
| mysql_num_fields | Return the number of columns in a result set. |
| mysql_num_rows | Returns the number of rows in result set. |
| mysql_query | Executes a SQL query. |
| mysql_real_query | Executes a SQL query with length information. |
| mysql_reload | Reload the user permissions table in the server. |
| mysql_select_db | Connect to a database. |
| mysql_shutdown | Shut down the database server. |
| mysql_stat | Return server status in a string. |
| mysql_store_result | Reads a result set to the client. |
| mysql_use_result | Initiate a dynamic result set for each row. |
int mysql_affected_rows(MYSQL *mysql)
void mysql_close(MYSQL *mysql)
MYSQL *mysql_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd)
int mysql_create_db(MYSQL *mysql, const char *db)
void mysql_data_seek(MYSQL_RES *res, uint offset)
int mysql_drop_db(MYSQL *mysql, const char *db)
int mysql_eof(MYSQL_RES *)
char *mysql_error(MYSQL *mysql)
MYSQL_FIELD *mysql_fetch_field(MYSQL_RES *handle)
BLOB without retreving a result
MySQL returns the 'default blob length', which is 8192, when
doing a select on the table. When one retrevies a result,
column_object->max_length contains the real max_length for the specific
query.
The 8192 is chosen because MySQL doesn't know the max length
for the blob object. This should be made configurable sometime.
unsigned int *mysql_fetch_lengths(MYSQL_RES *mysql)
MYSQL_ROW mysql_fetch_row(MYSQL_RES *mysql)
void mysql_field_seek(MYSQL_RES *result, int field)
void mysql_free_result(MYSQL_RES *result)
char *mysql_get_client_info(void)
char *mysql_get_host_info(MYSQL *mysql)
int mysql_get_proto_info(MYSQL *mysql)
char *mysql_get_server_info(MYSQL *mysql)
int mysql_insert_id(MYSQL *mysql)
MYSQL_RES *mysql_list_dbs(MYSQL *mysql, const char *wild)
MYSQL_RES *mysql_list_fields(MYSQL *mysql, const char *table, const char *wild)
MYSQL_RES *mysql_list_processes(MYSQL *mysql)
MYSQL_RES *mysql_list_tables(MYSQL *mysql, const char *wild)
int mysql_num_fields(MYSQL_RES *result)
int mysql_num_rows(MYSQL_RES *result)
int mysql_query(MYSQL *mysql, const char *query)
int mysql_real_query(MYSQL *mysql, const char *query, uint length)
int mysql_reload(MYSQL *mysql)
int mysql_select_db(MYSQL *mysql, const char *db)
int mysql_shutdown(MYSQL *mysql)
char *mysql_stat(MYSQL *mysql)
MYSQL_RES *mysql_store_result(MYSQL *mysql)
MYSQL_RES *mysql_use_result(MYSQL *mysql)
mysql_query() returns success, mysql_store_result() sometimes returns NULL?It means one of the following:
INSERT
or UPDATE or DELETE).
You can always check if the statement should have given a result by
checking that mysql_num_columns(MYSQL *) isn't 0. If this is 0
the last query was a statement that does not return values. For example
a INSERT or a DELETE.
You have got an error if mysql_error(MYSQL *) isn't empty!
mysql_affected_rows(MYSQL *) returns the number of affected
rows in the last query when doing an INSERT, UPDATE or DELETE. Except,
if DELETE is used without a where clause then the table is truncated
which is much faster!. In this case it returns records affected as zero.
mysql_insert_id(MYSQL *) returns the given ID of the last
query when inserting a row into a table with a AUTO_INCREMENT index.
See section 17.1.3 How can I get the unique ID for the last inserted row?
Some queries, LOAD DATA INFILE... and INSERT INTO
... SELECT ..., return additional info. The result is returned in
mysql_info(MYSQL *). mysql_info() returns a null pointer
if there is no additional information.
If you insert a record that has a AUTO_INCREMENT index then you
can get the given id with mysql_insert_id(MYSQL *).
The last value is also stored in the server and can be retrieved with
the LAST_INSERT_ID() function.
You can check if an auto_increment index is used by the following
code. This also checks if the query was a insert with a
auto_increment index.
if (mysql_error(MYSQL)[0] == 0 &&
mysql_num_fields(MYSQL_RESULT) == 0 &&
mysql_insert_id(MYSQL) != 0)
used_id = mysql_insert_id(MYSQL);
The id that LAST_INSERT_ID() returns is maintained in the server
per connection. It will not be botched by another client. It will not
even be changed if you update another auto_increment column with a non
magic value (that is a not null or 0).
mysql_use_result() and mysql_store_result() modes?
mysql_use_results reads the result directly from the server without
storing it in a local buffer. This is somewhat faster and uses much less
memory thatn mysql_store_result. One shouldn't use
mysql_use_results if there is a lot of processing being done for
each row at the client side, or if the output is sent to a screen on which
the user may do a ^S (stop scroll). Doing this would tie up the server
and then other threads can't update the used tables. One can't
use mysql_data_seek or issue other queries while using
mysql_use_result.
When linking with the C API you can get the following errors on some systems:
gcc -g -o client test.o -L/usr/local/lib/mysql -lmysqlclient -lsocket -lnsl Undefined first referenced symbol in file floor /usr/local/lib/mysql/libmysqlclient.a(password.o) ld: fatal: Symbol referencing errors. No output written to client
This means that on your system you have to include the math library (-lm) last in the compile/link line.
The client is 'almost' thread-safe. The biggest problem is that net.c (the subroutines that read from sockets) are not interrupt safe. This was done with the thought that one may want to have one's own alarm that can break a long read to a server.
The standard client libraries are not compiled with the thread options.
To get a thread safe client use the -lmysys, -lstring and
-ldbug libraries and net_serv.o that the server uses.
When using a threaded client I think one can have great use of the thr_alarm.c routine. If you are using the mysys routines, the only thing one has to remember is to call my_init() first!
All functions except mysql_connect() are currently thread safe.
To get connect thread_safe you have to do the following:
Recompile the client with:
CPPFLAGS=-DTHREAD_SAFE_CLIENT ./configure ...
You may get some errors because of undefined symbols when linking the standard client as the pthread libraries are not included by default.
The resulting libmysqld.a library is now thread safe.
Two treads can't use the same handle (returned by
mysql_connect()) at the same time, even if two threads can use
different MYSQL_RES handles that was created with
mysql_store_result().
When using a threaded client one can have great use of the thr_alarm.c routine. If you are using the mysys routines, the only thing one has to remember is to call my_init() first!
Since DBI/DBD now is the recommended perl interface mysqlperl is
not documented here.
DBI with DBD::mysql
DBI is a generic interface for many databases. That means that
you can write a script what works with many different database engines
without change. You need a DataBase Driver (DBD) defined for each
database type. For MySQL, this driver is called
DBD::mysql.
For more information on the Perl5 DBI, please visit DBIs web page and read the documentation. For more information on Object Oriented Programming (OOP) as defined in Perl5, see The perl OOP page.
Portable DBI methods.
| connect | Establish a connection to a database server |
| prepare | Get a SQL statement ready for execution |
| do | Prepares and executes a SQL statement |
| disconnect | Disconnect from the database server |
| quote | Quote strings/blobs to be inserted |
| execute | Executes prepared statements |
| fetchrow_array | fetch the next row as an array of fields. |
| fetchrow_arrayref | fetch next row as a reference array of fields |
| fetchrow_hashref | fetch next row as a reference to a hashtable |
| fetchall_arrayref | Get all data as a array of arrays |
| finish | finish a statment and let the system free resources |
| rows | Returns the number of rows affected |
| data_sources | Return an array of databases available on localhost |
| ChopBlanks | Shall fetchrow trim spaces |
| NUM_OF_PARAMS | Number of placeholders in the prepared statement |
| NULLABLE | Which columns can be NULL |
| insertid | The latest auto_increment value |
| is_blob | Which column ar BLOBs |
| is_key | Which columns are keys |
| is_num | Which columns are numeric |
| is_pri_key | Which columns are primary keys |
| is_not_null | Which columns can NOT be NULL. See NULLABLE |
| length | Maximum theoretically possible column sizes |
| max_length | Maximum physical present column sizes |
| NAME | Column names |
| NUM_OF_FIELDS | Number of fields returned. |
| table | Table names in returned set |
| type | All coulumn types |
| _CreateDB | Create a database |
| _DropDB | Drop a database. THIS IS DANGEROUS |
connect
$data_source value should begin with
DBI:driver_name:.
Example connect methods with the DBD::mysql driver:
$dbh = DBI->connect("DBI:mysql:$database", $user, $password);
$dbh = DBI->connect("DBI:mysql:$database:$hostname",
$user, $password);
$dbh = DBI->connect("DBI:mysql:$database:$hostname:$port",
$user, $password);
If the username and/or password are undefined, then the DBI will use the
values of the DBI_USER, DBI_PASS environment variables
respectively. If you don't specify a hostname, then it will default to
"localhost". If you don't specify a port, then it defaults to the
default mysql port (3333).
prepare
($sth) which invokes the execute
method. Example:
$sth = $dbh->prepare($statement) or die "Can't prepare $statement: $dbh->errstr\n";
do
$rc = $dbh->do($statement) or
die "Can't execute $statement: $dbh- >errstr\n";
disconnect
$rc = $dbh->disconnect;
quote
$sql = $dbh->quote($string)
execute
fetch_* methods below to retrieve the data. Example:
$rv = $sth->execute or die "can't execute the query: $sth->errstr;
fetchrow_array
while(@row = $sth->fetchrow_array) {
print qw($row[0]\t$row[1]\t$row[2]\n);
}
fetchrow_arrayref
while($row_ref = $sth->fetchrow_arrayref) {
print qw($row_ref->[0]\t$row_ref->[1]\t$row_ref->[2]\n);
}
fetchrow_hashref
while($hash_ref = $sth->fetchrow_hashref) {
print qw($hash_ref->{firstname}\t$hash_ref->{lastname}\t\
$hash_ref- > title}\n);
}
fetchall_arrayref
my $table = $sth->fetchall_arrayref or die "$sth->errstr\n";
my($i, $j);
for $i ( 0 .. $#{$table} ) {
for $j ( 0 .. $#{$table->[$i]} ) {
print "$table->[$i][$j]\t";
}
print "\n";
}
finish
$rc = $sth->finish;
rows
$rv = $sth->rows;
NULLABLE
$null_possible = $sth->{NULLABLE};
NUM_OF_FIELDS
$nr_of_fields = $sth->{NUM_OF_FIELDS};
data_sources
@dbs = DBI->data_sources("mysql");
ChopBlanks
$sth->{'ChopBlanks') =1;
insertid
$new_id = $sth->{insertid};
is_blob
$keys = $sth->{is_blob};
is_key
$keys = $sth->{is_key};
is_num
$nums = $sth->{is_num};
is_pri_key
$pri_keys = $sth->{is_pri_key};
is_not_null
$not_nulls = $sth->{is_not_null};
max_length
length
$max_lengts = $sth->{max_length};
$lengts = $sth->{length};
NAME
$names = $sth->{NAME};
table
$tables = $sth->{table};
You can use the perldoc command to get more information about DBI.
perldoc DBI perldoc DBI::FAQ perldoc mysql
You can also use the pod2man, pod2html, etc.. tools to
translate to other formats.
And of course you can find the latest DBI information at
the DBI web page
.
Insert pointers/descriptions of JDBC.
Insert pointers/descriptions of PHP.
Insert pointers/descriptions for C++.
Insert pointers/descriptions for Python.
Insert pointers/descriptions for TCL.
mSQLThis section has been written by the MySQL developers so it should be read with that in mind. But there are NO factual errors that we know of.
For a list of all supported limits, functions and types see the
crash-me web page.
mSQL can get patalogically slow if you chage the order of tables
in a select. In the benchmark suite a time more that 15000 times slower
than MySQL was seen.
Because of no thread creation overhead, small parser, few features and
simple security mSQL should be quicker at:
CREATE TABLE and DROP TABLE.
SELECT one something that isn't a index. (A table scan is very
easy)
mSQL and
most other SQL implementions on the following:
mSQL all other
connections have to wait until the first, doesn't matter whether the
query is long or short, is executed and finished. After that the next
connection can be served, while all the others wait again, etc.
ORDER BY and GROUP BY.
DISTINCT.
TEXT or BLOB columns.
GROUP BY & HAVING
MySQL supports a full GROUP BY with both HAVING
and the following functions count(), avg(), min(),
max(), sum() and std(). min() and
max() may take string arguments. count(*) is optimised to
return very quickly if this is the only thing in the query. mSQL
does not support GROUP BY at all.
INSERT & UPDATE with calculations.
MySQL can do calculations in a INSERT or UPDATE.
UPDATE SET x=x*10+y WHERE x<20;
SELECT with functions
MySQL has too many functions to list here. See section 7.3 Functions for use in SELECT and WHERE clauses.
mSQL2 only has 4 types (char,text,int,real) it is hard to
get small tables.
mSQL stability so we can not say
anything about that.
mSQL and is also cheaper than
mSQL. Remember to at least consider paying for a license or email
support for whatever product you choose to use. If you sell a product
with MySQL you are of course required to get a license for
this.
mSQL with some
added features.
mSQL has one but we have too little experience with
it to compare.
mSQL, it has a lot of catching up
to do. To get some perspective on this you can view the mSQL
HISTORY file for the last year and compare it with the News
section. See section C MySQL change history. It should be pretty obvious which one has
developed most rapidly.
mSQL and MySQL has a lot of interesting third party
tools. Since it is very easy to port upwars (mSQL ->
MySQL) MySQL has almost all interesting mSQL
applications.
MySQL comes with a simple msql2mysql program that fixes the different
spelling of the most used functions. A conversion of a client program
from mSQL to mySQL usually takes a couple of minutes.
mSQL tools like msql-tcl, msqljava?
According to our experience it would just take a few hours to convert a
tool using the mSQL C API to the MySQL C API.
The procedure:
Differences between the MySQL and mSQL C API's.
mSQL uses an
int).
mSQL only returns a text error
mSQL are the MySQL client/server communications protocols?There are enough differences that it is impossible (at least not easy) to support both.
The greatest differences between MySQL and mSQL are:
mSQL 2.0?CREATE TABLE
MySQL
UNSIGNED option for all integer columns.
ZEROFILL option for all integer columns.
AUTO_INCREMENT option for all integer columns that also is a
PRIMARY KEY. See section 17.1.3 How can I get the unique ID for the last inserted row?.
DEFAULT value for all columns.
ENUM type for one of a set of strings.
SET type for many of a set of string.
BIGINT type for 64 bit integers.
mSQL2
mSQL type | Corresponding MySQL type. |
| char(len) | char(len) |
| text(len) | text(len). len is the maximal length. And LIKE works.
|
| int | int. With many more options! |
| real | real. Or float. Both 4 and 8 bytes versions are available. |
| uint | Unsigned integer. |
| date | date. Takes ANSI SQL format instead of mSQLs own.
|
| time | time |
| money | decimal(12,2). A fixed point value with two decimals. |
MySQL
CREATE TABLE. Indexes can not be
removed without recreating the table. See section 7.7 ALTER TABLE syntax.
mSQL
CREATE INDEX
clause. Indexes may be removed with DROP INDEX.
MySQL
AUTO_INCREMENT as a column type
specifier. See section 17.1.3 How can I get the unique ID for the last inserted row?.
mSQL
SEQUENCE on a table and select the _seq column.
MySQL
PRIMARY KEY to the table.
mSQL
_rowid column. Observe that _rowid may change
depending on many factors.
MySQL
TIMESTAMP column to the table. And insert update it with a
NULL value. It when sutomaticaly gets the current time.
mSQL
_timestamp column.
MySQL
LIKE is always case insensitive. Also if possible MySQL
uses indexes if the like argument doesn't start with a wild-card.
mSQL
CLIKE.
MySQL
CHAR and VARCHAR
columns. Currently use a TEXT column if this behavior is
undesired.
mSQL
WHERE statement?
MySQL
mSQL behaviour in MySQL, use
parenthesis: select * from table where a=1 and b=2 or a=3 and b=4
-> select * from table where (a=1 and (b=2 or (a=3 and (b=4)))).
mSQL
MySQL
mSQL
For a list of all supported limits, functions and types see the crash-me web page.
PostgreSQL has some more advanced features like user defined types, triggers, rules and transactions. But it lacks a lot of the standard types and functions from ANSI SQL and ODBC. See the crash-me web page for a complete list of supported/unsupported types/function.
Normally PostgreSQL is much slower than MySQL. See section 12 MySQL benchmark suite.
Contributors to the MySQL distribution in somewhat random order:
mysqld.
MISAM library (A B-tree index file handler with index
compression and different record formats).
mSQL tools like msqlperl, DBD/DBI and DB2mysql.
texi2html. Also automatic website updating from
this manual.
Other contributors, bugfinders and testers: James H. Thompson, Maurizio Menghini, Wojciech Tryc, Luca Berra, Zarko Mocnik, Wim Bonis, Elmar Haneke, jehamby@lightside, psmith@BayNetworks.COM, duane@connect.com.au, root@dondra.ofc.psyber.com
And lots of bug report/patches from the folks on the mailing list.
And a big tribute to those that helps us answer question on the mysql@tcx.se mailing list.
REVERSE() (by Zeev Suraski)
LEFT OUTER JOIN.
LEFT, NATURAL,
USING
MYSQL_HOST as the default host if it's defined.
SELECT column, SUM(expr) now returns NULL for column when
there are matching rows.
POWER(), SPACE(),
COT(), DEGREES(), RADIANS(), ROUND(2 arg)
and TRUNCATE().
LOCATE() parameters where
swapped according to ODBC standard. Fixed.
TIME_TO_SEC().
NOT NULL fields.
UPDATE SET ... if the timestamp was
used as.
BLOB and TEXT to
be compatible with mysqldump.
DATE '1997-01-01', TIME '12:10:10' and
TIMESTAMP '1997-01-01 12:10:10' formats required by ANSI SQL.
WARNING INCOMPATIBLE CHANGE!! This has the unfortunate
side-effect that one can't have columns named DATE, TIME
or TIMESTAMP anymore :( Old columns can only be accessed with
'tablename.columnname'!
REPLACE, which works like INSERT but
replaces conflicting records with the new record. REPLACE INTO
TABLE ... SELECT ... works also.
CREATE DATABASE db_name and DROP
DATABASE db_name.
RENAME option to ALTER TABLE: ALTER TABLE name
RENAME AS new_name.
net_write() to my_net_write() because of name
conflict with sybase.
DAYOFWEEK() compatible with ODBC.
NULL
if the returned string should be longer than max_allowed_packet.
INTERVAL type to ENUM, because
INTERVAL is used in ANSI SQL.
TRIM() function.
CURTIME().
ENCRYPT() function by Zeev Suraski.
FOREIGN KEY syntax skipping. New reserved words:
MATCH, FULL, PARTIAL
--bind-address option.
NOT NULL to be after the
DEFAULT value as specified in the ANSI SQL standard. This will
make mysqldump with NOT NULL and default values incompatible with
MySQL 3.20.
ALTER TABLE person ALTER COLUMN phone SET DEFAULT NULL
syntax.
TEXT type. All
ODBC 2.5 functions is also supported (added REPAT). This gives better
portability.
TINYTEXT, TEXT, MIDDLETEXT and
LONGTEXT. These are actually blobs, but all searching is done
case independent.
BLOB fields are now TEXT fields. This only
changes that all searching on strings are case independent. One have to
do a ALTER TABLE and change the field to BLOB if one wants to have tests
done case dependent.
LOCK TABLES table_name [AS alias] (READ | WRITE), ...
mysqld --log-update to get a log suitable for
incremental updates
FIELD_TYPE_TINY_BLOB, FIELD_TYPE_MEDIUM_BLOB,
FIELD_TYPE_LONG_BLOB or FIELD_TYPE_VAR_STRING (as
previously returned by mysql_list_fields). One should instead only use
FIELD_TYPE_BLOB or FIELD_TYPE_STRING. If one wants exact
types one should use the command SHOW FIELDS .
0x###### which can be used as a string
(default) or a number.
FIELD_TYPE_CHAR is renamed to FIELD_TYPE_TINY.
DEFAULT doesn't have to be NOT NULL
anymore.
INTERVAL
SET
Changes from 3.20.18 to 3.20.32b are not documented here since the the 3.21 release bransched here. And the relevant changes are also documented as changes to the 3.21 version.
max_allowed_packet is now 65K for the server
and 512K for the client. This is mainly used to catch wrong packets that
could trash all memory. The server limit may be changed when it is
started.
ELT() function is renamed to FIELD(). The new
ELT() function returns a value based on a index: FIELD()
is the invers of ELT() Example: ELT(2,"A","B","C") returns
"B". FIELD("B","A","B","C") returns 2;
LIKE is always case insensitive.
SELECT id,lookup.text,sum(*) FROM test,lookup WHERE test.id=lookup.id group by id;
-lmysqlclient. This is the only library that needs to be linked
with client applications. When using the binary releases one have to
link with -lmysql -lmysys -ldbug -lstrings as before.
GROUP BY or ORDER BY or
DISTINCT. Only the first max_sort_length (default 1024)
are used when comparing blobs in these cases. This can be changed with
the -O max_sort_length parameter to mysql. A workaround for most
cases is to use a substring: SELECT DISTINCT LEFT(blob,2048) FROM
table.
bigint or double (both are
normally 64 bit long). It depends on the function which precision one
gets. 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.
SELECT * FROM table WHERE name = 'david '
For platform specific bugs see the sections about compiling and porting.
Everything in this list is in the order it will be done. If you want to affect the priority order, please register a licence or support us and tell us what you want to have done more quickly. See section 3 Licensing or When do I have/want to pay for MySQL?.
Time is given according to amount of work, not real time. TcX's main business is the use of MySQL not the development of it. But since TcX is a very flexible company and we have put a lot of resources into the development of MySQL.
LOCK
TABLES/UNLOCK TABLES but we will make this more automatic in the
future.
A working Posix thread library is needed for the server. On Solaris 2.5 we use SUN PThreads (the native thread support in 2.4 and earlier versions are not good enough) and on Linux we use LinuxThreads by Xavier Leroy Xavier.Leroy@inria.fr.
The hard part of porting to a new UNIX variant without good native thread support is probably to port MIT threads. See `mit-pthreads/README' and Programming POSIX Threads.
The MySQL distribution includes a patched version of Provenzano's Pthreads from MIT (see MIT Pthreads web page). This can be used for some operating systems that does not have posix threads.
It is also possible to use another user level thread package named FSU Pthreads (see FSU pthread home page). This implementation is being used for the SCO port.
See the `thr_lock.c' and `thr_alarm.c' programs in the mysys directory for some tests/examples of these problems
Both the server and the client needs a working C++ compiler (we use gcc and have tried SparcWorks). Other compiler that is known to work is the IRIX cc.
To compile only the client use `./configure --without-server'
There currently no support for only compiling the server. Nor is it likly to be added unless someone has a good reason for it.
If you want/need to change any Makefile or the configure script you must get automake and autoconf. We have used autoconf-2.12 and automake-1.2.
All steps needed to remake everything from the most basic files.
/bin/rm */.deps/*.P /bin/rm -f config.cache aclocal autoheader aclocal automake autoconf ./configure --with-debug=yes --prefix='your installation directory' # The makefiles generated above needs GNU make (called gmake below) gmake clean all install init-db
If you have some very specific problem, you can always try to debug MySQL.
Start the mysql server with a trace log in /tmp/mysql.trace. The log file will get very BIG.
mysqld --debug
or you can start it with
mysqld --debug=d,info,error,query,general,where:O,/tmp/mysql.trace
which only prints information with the most interesting tags.
I have tried to use the RTS thread packages with MySQL but stumbled on the following problems:
They use old version of a lot of POSIX calls and it is very tedious to make wrappers for all functions. I am inclined to think that it would be easier to change the thread libraries to the newest POSIX specification.
Some wrappers are already written. Se mysys/my_pthread.c for more info.
At least the following should be changed:
pthread_get_specific should use on argument. sigwait should take two arguments. A lot of functions (at least pthread_cond_wait, pthread_cond_timedwait) should return the error code on error. Now they return -1 and set errno.
Another problem is that user level threads uses the ALRM signal and this aborts a lot of functions (read, write, open...). MySQL should do a retry on interrupt on all of these but it not that easy to verify it.
The biggest unsolved problem is the following:
To get thread_level alarms I changed mysys/thr_alarm.c to wait between alarms with pthread_cond_timedwait() but this aborts with error EINTR. I tried to debug the thread library why this happens but couldn't find any easy solution.
If someone wants to try MySQL with RTS threads I suggest the following:
Main thread: 1 Tread 0 (5) started Thread: 5 Waiting process_alarm Tread 1 (6) started Thread: 6 Waiting process_alarm process_alarm thread_alarm Thread: 6 Sleeped for 1 (1) sec Thread: 6 Waiting process_alarm process_alarm thread_alarm Thread: 6 Sleeped for 2 (2) sec Thread: 6 Simulation of no alarm needed Thread: 6 Sleeped for 0 (3) sec Thread: 6 Waiting process_alarm process_alarm thread_alarm Thread: 6 Sleeped for 4 (4) sec Thread: 6 Waiting process_alarm thread_alarm Thread: 5 Sleeped for 10 (10) sec Thread: 5 Waiting process_alarm process_alarm thread_alarm Thread: 6 Sleeped for 5 (5) sec Thread: 6 Waiting process_alarm process_alarm ... thread_alarm Thread: 5 Sleeped for 0 (1) sec end
MySQL is very dependent on the used thread package. So when choosing a good platform for MySQL the thread package is very important.
There are at least three types of thread packages.
In some systems kernel threads are managed by integrating user level threads in the system libraries. In such cases, the thread switching can only be done by the thread library and the kernel isn't really 'thread aware'.
Regular expressions are a powerful way of specifying complex searches.
MySQL uses regular Henry Spencers inplementation of regular expressions. And that is aimed to conform to POSIX 1003.2. MySQL uses the extended version.
To get more exact information see Henry Spencers regex.7 manual that is included in the source distribution. See section B Who has helped to make MySQL..
This is a simplistic reference that skips the details. From here on a regualr expressions is called a regexp.
A regular expression describes a set of strings. The simplest case is
one that has no special characters in it. For example the regexp
hello matches hello and nothing else.
Nontrivial regular expressions use certain special constructs so that
they can match more than one string. For example, the regexp
hello|word matches either the string hello or the string
word.
And a more comples example regexp B[an]*s matches any of the
strings Bananas, Baaaaas, Bs and all other string
starting with a B and continuing with any number of a
n and ending with a s.
The following special characters/constructs are known.
^
mysql> select "fo\nfo" regexp "^fo$"; -> 0 mysql> select "fofo" regexp "^fo"; -> 1
$
mysql> select "fo\no" regexp "^fo\no$"; -> 1 mysql> select "fo\no" regexp "^fo$"; -> 0
.
mysql> select "fofo" regexp "^f.*"; -> 1 mysql> select "fo\nfo" regexp "^f.*"; -> 1
a*
mysql> select "Ban" regexp "^Ba*n"; -> 1 mysql> select "Baaan" regexp "^Ba*n"; -> 1 mysql> select "Bn" regexp "^Ba*n"; -> 1
a+
mysql> select "Ban" regexp "^Ba+n"; -> 1 mysql> select "Bn" regexp "^Ba+n"; -> 0
a?
mysql> select "Bn" regexp "^Ba?n"; -> 1 mysql> select "Ban" regexp "^Ba?n"; -> 1 mysql> select "Baan" regexp "^Ba?n"; -> 0
de|abc
de or abc.
mysql> select "pi" regexp "pi|apa"; -> 1 mysql> select "axe" regexp "pi|apa"; -> 0 mysql> select "apa" regexp "pi|apa"; -> 1 mysql> select "apa" regexp "^(pi|apa)$"; -> 1 mysql> select "pi" regexp "^(pi|apa)$"; -> 1 mysql> select "pix" regexp "^(pi|apa)$"; -> 0
(abc)*
abc.
mysql> select "pi" regexp "^(pi)+$"; -> 1 mysql> select "pip" regexp "^(pi)+$"; -> 0 mysql> select "pipi" regexp "^(pi)+$"; -> 1
{1}
{2,3}
a*
a{0,}.
+
a{1,}.
?
a{0,1}.
i and no comma matches a sequence of exactly i matches of
the atom. An atom followed by a bound containing one integer i
and a comma matches a sequence of i or more matches of the atom.
An atom followed by a bound containing two integers i and
j matches a sequence of i through j (inclusive)
matches of the atom.
Both arguments must 0 >= value <= RE_DUP_MAX (default 255), and
if there are two of them, the second must be bigger or equal to the
first.
[a-dX]
[^a-dX]
a, b,
c, d or X. To include ] it has to be written
first. To include - it has to be written first or last. So
[0-9] matches any decimal digit. All character that does not have
a defined mening inside a [] pair has no special meaning and
macthes only itself.
mysql> select "aXbc" regexp "[a-dXYZ]"; -> 1 mysql> select "aXbc" regexp "^[a-dXYZ]$"; -> 0 mysql> select "aXbc" regexp "^[a-dXYZ]+$"; -> 1 mysql> select "aXbc" regexp "^[^a-dXYZ]+$"; -> 0 mysql> select "gheis" regexp "^[^a-dXYZ]+$"; -> 1 mysql> select "gheisa" regexp "^[^a-dXYZ]+$"; -> 0
[[.characters.]]
ch
collating element, then the RE [[.ch.]]*c matches the first five
characters of chchcc.
[=character-class=]
o and (+) are the members of an
equivalence class, then [[=o=]], [[=(+)=]], and
[o(+)] are all synonymous. An equivalence class may not be an
endpoint of a range.
[:character_class:]
[: and :] stands for the list of all characters belonging
to that class. Standard character class names are:
| alnum | digit | punct |
| alpha | graph | space |
| blank | lower | upper |
| cntrl | xdigit |
mysql> select "justalnums" regexp "[[:alnum:]]+"; -> 1 mysql> select "!!" regexp "[[:alnum:]]+"; -> 0
mysql> select "a word a" regexp "[[:<:]]word[[:>:]]"; -> 1 mysql> select "a xword a" regexp "[[:<:]]word[[:>:]]"; -> 0
mysql> select "weeknights" regexp "^(wee|week)(knights|nights)$"; -> 1
Unireg is our tty interface builder, but it uses a low level connection to our NISAM (with is used by MySQL) and because of this it is very quick. It has existed since 1979 (on Unix in C since ~1986).
Unireg has the following components:
We update most of our production databases with the UNIREG interface and serve web pages through MySQL (and in some extreme cases the UNIREG report generator).
Unireg takes about 3M of disk space and works on at least the following platforms: SUN OS 4.x, Solaris, Linux, HPUX, ICL Unix, DNIX, SCO and MSDOS.
Unireg is currently only available in Swedish and Finnish.
The price tag for UNIREG is 10,000 Swedish kr (about 1500$ US), but this includes support. UNIREG is distributed as a binary. (But all the ISAM sources can be found in MySQL). Usually we compile the binary for the customer at their site.
All new development is concentrated to MySQL.
MySQL FREE PUBLIC LICENSE (Version 4, March 5, 1995)
Copyright (C) 1995, 1996 TcX AB & Monty Program KB & Detron HB Stockholm SWEDEN, Helsingfors FINLAND and Uppsala SWEDEN All rights reserved.
NOTE: This license is not the same as any of the GNU Licenses published by the Free Software Foundation. Its terms are substantially different from those of the GNU Licenses. If you are familiar with the GNU Licenses, please read this license with extra care.
This License applies to the computer program known as "MySQL". The "Program", below, refers to such program, and a "work based on the Program" means either the Program or any derivative work of the Program, as defined in the United States Copyright Act of 1976, such as a translation or a modification. The Program is a copyrighted work whose copyright is held by TcX Datakonsult AB and Monty Program KB and Detron HB.
BY MODIFYING OR DISTRIBUTING THE PROGRAM (OR ANY WORK BASED ON THE PROGRAM), YOU INDICATE YOUR ACCEPTANCE OF THIS LICENSE TO DO SO, AND ALL ITS TERMS AND CONDITIONS FOR COPYING, DISTRIBUTING OR MODIFYING THE PROGRAM OR WORKS BASED ON IT. NOTHING OTHER THAN THIS LICENSE GRANTS YOU PERMISSION TO MODIFY OR DISTRIBUTE THE PROGRAM OR ITS DERIVATIVE WORKS. THESE ACTIONS ARE PROHIBITED BY LAW. IF YOU DO NOT ACCEPT THESE TERMS AND CONDITIONS, DO NOT MODIFY OR DISTRIBUTE THE PROGRAM.
This document was generated on 2 January 1998 using the texi2html translator version 1.52 (extended by davida@detron.se).