The C API code is distributed with MySQL. It is included in the
mysqlclient library and allows C programs to access a database.
Many of the clients in the MySQL source distribution are written in C. If
you are looking for examples that demonstrate how to use the C API, take a
look at these clients.
Most of the other client APIs (all except Java) use the
library to communicate with the MySQL server. This means that, for
example, you can take advantage of many of the same environment variables
that are used by other client programs, because they are referenced from the
library. See 12.1 Overview of the different MySQL programs, for a list of these variables.
The client has a maximum communication buffer size. The size of the buffer
that is allocated initially (16K bytes) is automatically increased up to the
maximum size (the default maximum is 24M). Since buffer sizes are increased
only as demand warrants, simply increasing the default maximum limit does not
in inself cause more resources to be used. This size check is mostly a check
for erroneous queries and communication packets.
The communication buffer must be large enough to contain a single SQL
statement (for client-to-server traffic) and one row of returned data (for
server-to-client traffic). Each thread's communication buffer is dynamically
enlarged to handle any query or row up to the maximum limit. For example, if
BLOB values that contain up to 16M of data, you must have a
communication buffer limit of at least 16M (in both server and client). The
client's default maximum is 24M, but the default maximum in the server is
1M. You can increase this by changing the value of the
max_allowed_packet parameter when the server is started. 10.1 Tuning server parameters.
The MySQL server shrinks each communication buffer to
net_buffer_length bytes after each query. For clients, the size of
the buffer associated with a connection is not decreased until the connection
is closed, at which time client memory is reclaimed.
If you are programming with threads, you should compile the
MySQL C API with
--with-thread-safe-client. This will make
the C API thread safe per connection. You can let two threads share the same
connection as long if you do the following:
Two threads can't send a query to the MySQL at the same time on
the same connection. In particular you have to ensure that between a
mysql_store_result() no other thread is using
the same connection.
Many threads can access different result sets that are retrieved with
If you use
mysql_use_result, you have to ensure that no other thread
is asking anything on the same connection until the result set is closed.