Oracle 5.0 Reference Manual page 2558

Statistic Scope Description
Connection N umber of statements prepared but
ps_prepared_never_executed
never executed.
Connection N umber of prepared statements
ps_prepared_once_executed
executed only one.
Connection T otal number of result set rows
rows_fetched_from_server_normal,
successfully fetched from MySQL
rows_fetched_from_server_ps
regardless if the client application has
consumed them or not. Some of the
rows may not have been fetched by the
client application but have been flushed
implicitly.
Connection T otal number of successfully buffered
rows_buffered_from_client_normal,
rows originating from a "normal" query
rows_buffered_from_client_ps
or a prepared statement. This is the
number of rows that have been fetched
from MySQL and buffered on client.
Note that there are two distinct statistics
on rows that have been buffered
(MySQL to mysqlnd internal buffer) and
buffered rows that have been fetched
by the client application (mysqlnd
internal buffer to client application).
If the number of buffered rows is
higher than the number of fetched
buffered rows it can mean that the client
application runs queries that cause
larger result sets than needed resulting
in rows not read by the client.
Connection T otal number of rows fetched by the
rows_fetched_from_client_normal_buffered,
client from a buffered result set created
rows_fetched_from_client_ps_buffered
by a normal query or a prepared
statement.
Connection T otal number of rows fetched by the
rows_fetched_from_client_normal_unbuffered,
client from a unbuffered result set
rows_fetched_from_client_ps_unbuffered
MySQL Native Driver (Mysqlnd)
2538
Notes
Prepared statements occupy server
resources. You should not prepare a
statement if you do not plan to execute
it.
One of the ideas behind prepared
statements is that the same query gets
executed over and over again (with
different parameters) and some parsing
and other preparation work can be
saved, if statement execution is split
up in separate prepare and execute
stages. The idea is to prepare once
and "cache" results, for example, the
parse tree to be reused during multiple
statement executions. If you execute
a prepared statement only once the
two stage processing can be inefficient
compared to "normal" queries because
all the caching means extra work and it
takes (limited) server resources to hold
the cached information. Consequently,
prepared statements that are executed
only once may cause performance
hurts.
See also
packets_received_rset_row
Examples of queries that will
buffer results: mysqli_query,
mysqli_store_result