Version sans cache
Mise en cache désactivé. Réglage défaut pour cette page : actif (code DEF204)Si l'affichage est trop lent, vous pouvez désactiver le mode utilisateur pour visualiser la version en cache.
Rechercher dans le manuel MySQL
28.7.10 C API Prepared Statement Function Overview
The following list summarizes the functions available for prepared statement processing. For greater detail, see the descriptions in Section 28.7.11, “C API Prepared Statement Function Descriptions”.
mysql_stmt_affected_rows(): Returns the number of rows changed, deleted, or inserted by preparedUPDATE,DELETE, orINSERTstatement.mysql_stmt_attr_get(): Gets the value of an attribute for a prepared statement.mysql_stmt_attr_set(): Sets an attribute for a prepared statement.mysql_stmt_bind_param(): Associates application data buffers with the parameter markers in a prepared SQL statement.mysql_stmt_bind_result(): Associates application data buffers with columns in a result set.mysql_stmt_close(): Frees memory used by a prepared statement.mysql_stmt_data_seek(): Seeks to an arbitrary row number in a statement result set.mysql_stmt_errno(): Returns the error number for the last statement execution.mysql_stmt_error(): Returns the error message for the last statement execution.mysql_stmt_execute(): Executes a prepared statement.mysql_stmt_fetch(): Fetches the next row of data from a result set and returns data for all bound columns.mysql_stmt_fetch_column(): Fetches data for one column of the current row of a result set.mysql_stmt_field_count(): Returns the number of result columns for the most recent statement.mysql_stmt_free_result(): Frees the resources allocated to a statement handler.mysql_stmt_init(): Allocates memory for aMYSQL_STMTstructure and initializes it.mysql_stmt_insert_id(): Returns the ID generated for anAUTO_INCREMENTcolumn by a prepared statement.mysql_stmt_next_result(): Returns/initiates the next result in a multiple-result execution.mysql_stmt_num_rows(): Returns the row count from a buffered statement result set.mysql_stmt_param_count(): Returns the number of parameters in a prepared statement.mysql_stmt_param_metadata(): Returns parameter metadata in the form of a result set. (This function actually does nothing.)mysql_stmt_prepare(): Prepares an SQL statement string for execution.mysql_stmt_reset(): Resets the statement buffers in the server.mysql_stmt_result_metadata(): Returns prepared statement metadata in the form of a result set.mysql_stmt_row_seek(): Seeks to a row offset in a statement result set, using value returned frommysql_stmt_row_tell().mysql_stmt_row_tell(): Returns the statement row cursor position.mysql_stmt_send_long_data(): Sends long data in chunks to server.mysql_stmt_sqlstate(): Returns the SQLSTATE error code for the last statement execution.mysql_stmt_store_result(): Retrieves a complete result set to the client.
Call mysql_stmt_init() to create a
statement handler, then
mysql_stmt_prepare() to prepare
the statement string,
mysql_stmt_bind_param() to supply
the parameter data, and
mysql_stmt_execute() to execute
the statement. You can repeat the
mysql_stmt_execute() by changing
parameter values in the respective buffers supplied through
mysql_stmt_bind_param().
You can send text or binary data in chunks to server using
mysql_stmt_send_long_data(). See
Section 28.7.11.26, “mysql_stmt_send_long_data()”.
If the statement is a SELECT or any
other statement that produces a result set,
mysql_stmt_prepare() also returns
the result set metadata information in the form of a
MYSQL_RES result set through
mysql_stmt_result_metadata().
You can supply the result buffers using
mysql_stmt_bind_result(), so that
the mysql_stmt_fetch()
automatically returns data to these buffers. This is row-by-row
fetching.
When statement execution has been completed, close the statement
handler using mysql_stmt_close()
so that all resources associated with it can be freed. At that
point the handler becomes invalid and should no longer be used.
If you obtained a SELECT
statement's result set metadata by calling
mysql_stmt_result_metadata(), you
should also free the metadata using
mysql_free_result().
Execution Steps
To prepare and execute a statement, an application follows these steps:
Create a prepared statement handler with
mysql_stmt_init(). To prepare the statement on the server, callmysql_stmt_prepare()and pass it a string containing the SQL statement.If the statement will produce a result set, call
mysql_stmt_result_metadata()to obtain the result set metadata. This metadata is itself in the form of result set, albeit a separate one from the one that contains the rows returned by the query. The metadata result set indicates how many columns are in the result and contains information about each column.Set the values of any parameters using
mysql_stmt_bind_param(). All parameters must be set. Otherwise, statement execution returns an error or produces unexpected results.Call
mysql_stmt_execute()to execute the statement.If the statement produces a result set, bind the data buffers to use for retrieving the row values by calling
mysql_stmt_bind_result().Fetch the data into the buffers row by row by calling
mysql_stmt_fetch()repeatedly until no more rows are found.Repeat steps 3 through 6 as necessary, by changing the parameter values and re-executing the statement.
When mysql_stmt_prepare() is
called, the MySQL client/server protocol performs these actions:
The server parses the statement and sends the okay status back to the client by assigning a statement ID. It also sends total number of parameters, a column count, and its metadata if it is a result set oriented statement. All syntax and semantics of the statement are checked by the server during this call.
The client uses this statement ID for the further operations, so that the server can identify the statement from among its pool of statements.
When mysql_stmt_execute() is
called, the MySQL client/server protocol performs these actions:
The client uses the statement handler and sends the parameter data to the server.
The server identifies the statement using the ID provided by the client, replaces the parameter markers with the newly supplied data, and executes the statement. If the statement produces a result set, the server sends the data back to the client. Otherwise, it sends an okay status and the number of rows changed, deleted, or inserted.
When mysql_stmt_fetch() is
called, the MySQL client/server protocol performs these actions:
The client reads the data from the current row of the result set and places it into the application data buffers by doing the necessary conversions. If the application buffer type is same as that of the field type returned from the server, the conversions are straightforward.
If an error occurs, you can get the statement error number,
error message, and SQLSTATE code using
mysql_stmt_errno(),
mysql_stmt_error(), and
mysql_stmt_sqlstate(),
respectively.
For prepared statements that are executed with the
mysql_stmt_prepare() and
mysql_stmt_execute() C API
functions, the server writes Prepare and
Execute lines to the general query log so
that you can tell when statements are prepared and executed.
Suppose that you prepare and execute a statement as follows:
Call
mysql_stmt_prepare()to prepare the statement string"SELECT ?".Call
mysql_stmt_bind_param()to bind the value3to the parameter in the prepared statement.Call
mysql_stmt_execute()to execute the prepared statement.
As a result of the preceding calls, the server writes the following lines to the general query log:
Prepare [1] SELECT ?
Execute [1] SELECT 3
Each Prepare and Execute
line in the log is tagged with a
[ statement
identifier so that you can keep track of which prepared
statement is being logged. N]N is a
positive integer. If there are multiple prepared statements
active simultaneously for the client,
N may be greater than 1. Each
Execute lines shows a prepared statement
after substitution of data values for ?
parameters.
Traduction non disponible
Le manuel MySQL n'est pas encore traduit en français sur l'infobrol. Seule la version anglaise est disponible pour l'instant.
Document créé le 26/06/2006, dernière modification le 26/10/2018
Source du document imprimé : https://www.gaudry.be/mysql-rf-c-api-prepared-statement-function-overview.html
L'infobrol est un site personnel dont le contenu n'engage que moi. Le texte est mis à disposition sous licence CreativeCommons(BY-NC-SA). Plus d'info sur les conditions d'utilisation et sur l'auteur.
Références
Ces références et liens indiquent des documents consultés lors de la rédaction de cette page, ou qui peuvent apporter un complément d'information, mais les auteurs de ces sources ne peuvent être tenus responsables du contenu de cette page.
L'auteur de ce site est seul responsable de la manière dont sont présentés ici les différents concepts, et des libertés qui sont prises avec les ouvrages de référence. N'oubliez pas que vous devez croiser les informations de sources multiples afin de diminuer les risques d'erreurs.
