Merge lp:~vlad-lesin/percona-server/5.6-binary-answer into lp:percona-server/5.6

[Vlad Lesin]

This branch is not supposed to be merged to PS5.6, all changes should be applied to the custom tree. But the fixes where ported to PS5.6 for comfortable testing and code review.

Testing on 5.6: http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/636

[Laurynas Biveinis (laurynas-biveinis)]

    - This appears to implement
      http://dev.mysql.com/worklog/task/?id=4627. Let's reference it
      in the blueprint. Is it a good idea to take their names
      COM_STMT_EXECUTE_IMMEDIATE and mysql_stmt_execute_immediate()?
    - The feature breaks forward client/server compatibility with
      Oracle. Is that why we are not merging this to PS 5.6 trunk?
    - The test program should exercise the binary protocol itself
      more, it's possible some corner case might fall out. Looking at
      the protocol description that entails testing the following:
      NULLs in result, and types listed in
      http://dev.mysql.com/doc/internals/en/binary-protocol-value.html
    - Another way to have good test coverage for the feature would be
      to patch run_query in mysqltest.cc, which happens to do
      prepare+execute in binary protocol, by this feature, and run
      testsuite with --ps-protocol, and watch for fallout. I am not
      sure whether this should be done as a one-time thing for
      testing, whether --ps-protocol should always do the binary query
      answer, or a a new option like --ps-protocol should be added.
    - On Mac OS X, the testcase fails with

--- /Users/laurynas/percona/lp-mysql-server/5.6-binary-answer/mysql-test/r/stmt_query.result 2014-07-15 14:41:41.000000000 +0300
+++ /Users/laurynas/percona/lp-mysql-server/5.6-binary-answer/obj-debug/mysql-test/var/log/stmt_query.reject 2014-07-15 15:12:00.000000000 +0300
@@ -24,5 +24,5 @@
 binary: 3, Volkswagen, 21600

 Test for error:
-Errno: 1146, error text: Table 'test.Bars' doesn't exist
+Errno: 1146, error text: Table 'test.bars' doesn't exist
 Errno: 1064, error text: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SELEC * FROM Bars' at line 1

    This is probably because

2014-07-15 15:11:56 62141 [Warning] Setting lower_case_table_names=2 because file system for /var/folders/sj/tww0v3g14tncqd9lsc81vqj80000gn/T/kL5oE2Hwjx/ is case insensitive

    - Not sure if I like COM_STMT_QUERY replacement with COM_QUERY in
      dispatch_command. On one hand, COM_STMT_QUERY is like COM_QUERY,
      onn another, like COM_EXECUTE, so it's not trivially obivous
      that all COM_QUERY checks automatically apply to COM_STMT_QUERY
      too. I'd rather leave the original command and add || ==
      COM_STMT_QUERY as necessary.

    Minor comments:
    - COM_STMT_QUERY in mysql_com.h should go above the "don't forget
      to update ... " comment.
    - args aligment in mysql_stmt_query_bind_result declaration (diff
      lines 16+ and 46+)
    - init_stmt_fields, cli_stmt_query, reinit_stmt_fields,
      mysql_stmt_query, mysql_stmt_query need header comments
    - spurious diff line 312
    - Was adding of emb_stmt_query necessary?
    - Why patching of mysql_stmt_bind_result was required?
    - diff line 472: bool x = (y == z) ? true : false is simply x = (y
      == z)

review: Needs Fixing

[Vlad Lesin (vlad-lesin)]

> - This appears to implement
> http://dev.mysql.com/worklog/task/?id=4627. Let's reference it
> in the blueprint. Is it a good idea to take their names
> COM_STMT_EXECUTE_IMMEDIATE and mysql_stmt_execute_immediate()?
Yes, this is a good naming. I will do renaming. This WL is only for one new api function but one more function is necessary for binding results as standard mysql_stmt_bind_result() requires some fields of MYSQL_STMT object to be initialized, and on normal workflow they are initialized inside of mysql_stmt_prepare().

> - The feature breaks forward client/server compatibility with
> Oracle. Is that why we are not merging this to PS 5.6 trunk?
If you mean that new command will not be supported in new mysql versions then yes, you are right. But as we discussed there are many such things which lead to forward incompatibility PS5.6 with Oracle Mysql.

> - The test program should exercise the binary protocol itself
> more, it's possible some corner case might fall out. Looking at
> the protocol description that entails testing the following:
> NULLs in result, and types listed in
> http://dev.mysql.com/doc/internals/en/binary-protocol-value.html
I don't think this is really necessary as there is no new code which would parse the protocol from client-side, absolutely the same functions are used for parsing answer from both "prepared" and "immediate" queries. And the same is true for server-side. And if there are any errors in binary protocol they will show itself during "prepare/execute" testing.

> - Another way to have good test coverage for the feature would be
> to patch run_query in mysqltest.cc, which happens to do
> prepare+execute in binary protocol, by this feature, and run
> testsuite with --ps-protocol, and watch for fallout. I am not
> sure whether this should be done as a one-time thing for
> testing, whether --ps-protocol should always do the binary query
> answer, or a a new option like --ps-protocol should be added.
Hey, thanks, great idea. I have implemented new --binary-protocol option. I will launch two jenkins jobs. One will be with --ps-protocol and another with --binary-protocol and then we will compare results. But again, this approach just tests some new sequence of C api calls for parsing binary answer. The rest of test is absolutely the same as for "prepare-execute" pair.

> - On Mac OS X, the testcase fails with
>
> --- /Users/laurynas/percona/lp-mysql-server/5.6-binary-answer/mysql-
> test/r/stmt_query.result 2014-07-15 14:41:41.000000000 +0300
> +++ /Users/laurynas/percona/lp-mysql-server/5.6-binary-answer/obj-debug/mysql-
> test/var/log/stmt_query.reject 2014-07-15 15:12:00.000000000 +0300
> @@ -24,5 +24,5 @@
> binary: 3, Volkswagen, 21600
>
> Test for error:
> -Errno: 1146, error text: Table 'test.Bars' doesn't exist
> +Errno: 1146, error text: Table 'test.bars' doesn't exist
> Errno: 1064, error text: You have an error in your SQL syntax; check the
> manual that corresponds to your MySQL server version for the right syntax to
> use near 'SELEC * FROM Bars' at line 1
>
> This is probab...

[Vlad Lesin (vlad-lesin)]

The new results of testing are here:
with --ps-protocol
http://jenkins.percona.com/view/PS 5.6/job/percona-server-5.6-param/685
with --binary-protocol
http://jenkins.percona.com/view/PS 5.6/job/percona-server-5.6-param/686

The tests are passed for --ps-protocol and not passed for --binary-protocol are the following:

main.kill
main.wait_timeout
main.parser
main.failed_auth_3909
main.mysql_binary_mode
main.query_cache_ps_no_prot
perfschema.event_aggregate
perfschema.event_aggregate_no_a
perfschema.event_aggregate_no_a_no_h
perfschema.event_aggregate_no_a_no_u
perfschema.event_aggregate_no_a_no_u_no_h
perfschema.event_aggregate_no_h
perfschema.event_aggregate_no_u
perfschema.event_aggregate_no_u_no_h
perfschema.nesting

[Vlad Lesin (vlad-lesin)]

The "reconnect" bug.

If MYSQL::reconnect flag is set reconnect does not happen on mysql_stmt_execute_immediate() call. There are several failed test connected with this bug. For example: main.kill, main.wait_timeout.

If MYSQL::reconnect flag is set and mysql_stmt_execute_immediate() is invoked the reconnection should be inside of cli_advanced_command() after net_write_command() returns error. But net_write_command() does not return error as send() function does not return error in inline_mysql_socket_send() too in the case if connection was closed by peer. As the data size to send is quite small send() just buffers the data. Here is the stacktrace:

(gdb) bt
#0 __libc_send (fd=7, buf=0x9f9ae0, n=13, flags=0)
    at ../sysdeps/unix/sysv/linux/x86_64/send.c:26
#1 0x0000000000438c6c in inline_mysql_socket_send (
    src_file=0x4c9e10 "./vio/viosocket.c", src_line=224, mysql_socket=..., buf=0x9f9ae0, n=13, flags=0)
    at ./include/mysql/psi/mysql_socket.h:759
#2 0x0000000000439597 in vio_write (vio=0x9f58d0, buf=0x9f9ae0 "\t", size=13)
    at ./vio/viosocket.c:224
#3 0x000000000041ea38 in net_write_raw_loop (net=0x7fffffff98c8,
    buf=0x9f9ae0 "\t", count=13)
    at ./sql/net_serv.cc:500
#4 0x000000000041ed0d in net_write_packet (net=0x7fffffff98c8,
    packet=0x9f9ae0 "\t", length=13)
    at ./sql/net_serv.cc:636
#5 0x000000000041e31f in net_flush (net=0x7fffffff98c8)
    at ./sql/net_serv.cc:220
#6 0x000000000041e7d9 in net_write_command (net=0x7fffffff98c8,
    command=31 '\037', header=0x0, head_len=0, packet=0x4c3eaf "SELECT 1",
---Type <return> to continue, or q <return> to quit---
    len=8)
    at ./sql/net_serv.cc:399
#7 0x0000000000413a08 in cli_advanced_command (mysql=0x7fffffff98c8,
    command=COM_STMT_EXECUTE_IMMEDIATE, header=0x0, header_length=0,
    arg=0x4c3eaf "SELECT 1", arg_length=8, skip_check=1 '\001', stmt=0x9fbb80)
    at ./sql-common/client.c:727
#8 0x000000000040914d in cli_stmt_execute_immediate (stmt=0x9fbb80,
    query=0x4c3eaf "SELECT 1", len=8)
    at ./libmysql/libmysql.c:2224
#9 0x0000000000409ba4 in mysql_stmt_execute_immediate (stmt=0x9fbb80,
    q=0x4c3eaf "SELECT 1")
    at ./libmysql/libmysql.c:2716
#10 0x0000000000404cfd in main (argc=2, argv=0x7fffffffa038)
    at ./tests/stmt_execute_immediate.cc:276

And the fact the connection was closed by peer is determined during the step of receiving data from server in cli_read_query_result(). But in this case reconnection does not happen.

Why does the reconnection happen if mysql_stmt_prepare() is used? Because send() is invoked twice in this case. The first time is for COM_STMT_CLEAR command and the second time is for COM_STMT_PREPARE. The first send() buffers the data and does not return error while the second call returns error. Here are the stacktraces:

(gdb) bt
#0 __libc_send (fd=7, buf=0x9f9ae0, n=9, flags=0)
    at ../sysdeps/unix/sysv/linux/x86_64/send.c:26
#1 0x0000000000438c99 in inline_mysql_socket_send (
    src_file=0x4c9e30 "./vio/viosocket.c", src_line=224, mysql_socket=..., buf=0x9f9ae0, n=9, flags=0)
    at ./include/mysql/psi/mysql_socket.h:759
#2 0x00000000004395c4 in vio_write (vio=0x9f58d0, buf=0x9f9ae0 "\005", siz...

[lp:~vlad-lesin/percona-server/5.6-binary-answer]

619. By Vlad Lesin on 2014-09-09

Implement this
https://blueprints.launchpad.net/percona-server/+spec/binary-answer-5.6
blueprint.

The task can be splitted on server and client parts.

Server-side.

If we look into mysqld_stmt_prepare() function we can see the code like this:

Protocol *save_protocol= thd->protocol;
thd->protocol= &thd->protocol_binary;
stmt->prepare(...);
thd->protocol= save_protocol;

The THD class contains this members:

Protocol *protocol; // Current protocol
Protocol_text protocol_text; // Normal protocol
Protocol_binary protocol_binary; // Binary protocol

So for server-side is enough to add new command COM_STMT_EXECUTE_IMMEDIATE which
would do absolutely the same things as COM_QUERY does but with replacing
thd->protocol with &thd->protocol_binary before processing and restore protocol
pointer after processing.

Client side.

Standard C API has already have all necessary infrastructure to parse binary
protocol. So the task is to use this infrastructure. The idea is to add new
function mysql_stmt_execute_immediate() which would send
COM_STMT_EXECUTE_IMMEDIATE to server, initialize MYSQL_STMT object to use it
for parsing result with standard functions for parsing the result of
"execute prepared statement". As well mysql_stmt_bind_immediate() is necessary
to initialize certain MYSQL_STMT fields which are usually initialized inside of
mysql_stmt_prepare() and to invoke standard mysql_stmt_bind_result() function
to describe the result data.

There are two functions to execute prepared and non-prepared queries
correspondingly: mysql_stmt_execute() and mysql_real_query(). Both functions
use the same function cli_read_query_result() to get information about fields
count, their names. So this part of result parsing is the same. But rows parsing
is absolutely different.

For non-prepared query mysql_fetch_row()->read_one_row() calls just set pointers
in array of rows to the certain values in read packet. As all values are in the
text format we have the array of pointers to null-terminated strings as the
output of the function.

But when binary data are parsed in mysql_stmt_fetch()->stmt_fetch_row() the
functions use information about field types from MYSQL_STMT::bind array.
For each element of this array
mysql_stmt_bind_result()->setup_one_fetch_function() sets the pointer to the
function which parses binary data of corresponding type to the buffer. For
example fetch_result_int32() is set up for MYSQL_TYPE_LONG data type.

So we have to develop new function mysql_stmt_execute_immediate() which would
mix mysql_real_query() and mysql_stmt_execute().

Use tests/stmt_execute_immediate.cc as the source of information about the
sequence of C API calls to send query and receive and parse binary answer.

stmt_execute_immediate.cc could be the part of mysql_client_test.c but the
customer disabled this test in his tree.

The new parameter --binary-protocol is added to mysqltest to allow communication
between client and server with binary protocol without "prepare" using
mysql_stmt_execute_immedate() function to send query.

[Vlad Lesin (vlad-lesin)]

> The "reconnect" bug.

The issue was in this code:

my_bool
cli_advanced_command(MYSQL *mysql, enum enum_server_command command,
       const uchar *header, ulong header_length,
       const uchar *arg, ulong arg_length, my_bool skip_check,
                     MYSQL_STMT *stmt)
{
...
  my_bool stmt_skip= stmt ? stmt->state != MYSQL_STMT_INIT_DONE : FALSE;
...
  if (mysql->net.vio == 0)
  { /* Do reconnect if possible */
    if (mysql_reconnect(mysql) || stmt_skip)
      DBUG_RETURN(1);
  }
...
}

As stmt->state was set to MYSQL_STMT_PREPARE_DONE value in mysql_stmt_execute_immediate(), the code did reconnect but did not send commend after the reconnect.

The fix is skipping stmt argument of cli_advanced_command() when it is invoked from cli_stmt_execute_immediate.

As well there was error in mysql_stmt_close(). The function used to send COM_STMT_SEND command to server, and as there is no valid statement ID for queries sent with mysql_stmt_execute_immediate(), the server returned error. The bug was fixed with checking statement ID for "undefined" value which is 0 as statement ID's begin with 1 (see THD::statement_id_counter, THD and Prepared_statement constructors). The "udefined" statement ID is set in mysql_stmt_execute_immediate().

After fixing these two bugs the number of failed tests ran with '--binary-protocol' option decreased dramatically. Here is the list:

    main.mysql_binary_mode
    main.parser
    main.query_cache_ps_no_prot
    perfschema.nesting
    rpl.rpl_err_ignoredtable 'row'

(http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/709)

Unmerged revisions

619. By Vlad Lesin on 2014-09-09

Implement this
https://blueprints.launchpad.net/percona-server/+spec/binary-answer-5.6
blueprint.

The task can be splitted on server and client parts.

Server-side.

If we look into mysqld_stmt_prepare() function we can see the code like this:

Protocol *save_protocol= thd->protocol;
thd->protocol= &thd->protocol_binary;
stmt->prepare(...);
thd->protocol= save_protocol;

The THD class contains this members:

Protocol *protocol; // Current protocol
Protocol_text protocol_text; // Normal protocol
Protocol_binary protocol_binary; // Binary protocol

So for server-side is enough to add new command COM_STMT_EXECUTE_IMMEDIATE which
would do absolutely the same things as COM_QUERY does but with replacing
thd->protocol with &thd->protocol_binary before processing and restore protocol
pointer after processing.

Client side.

Standard C API has already have all necessary infrastructure to parse binary
protocol. So the task is to use this infrastructure. The idea is to add new
function mysql_stmt_execute_immediate() which would send
COM_STMT_EXECUTE_IMMEDIATE to server, initialize MYSQL_STMT object to use it
for parsing result with standard functions for parsing the result of
"execute prepared statement". As well mysql_stmt_bind_immediate() is necessary
to initialize certain MYSQL_STMT fields which are usually initialized inside of
mysql_stmt_prepare() and to invoke standard mysql_stmt_bind_result() function
to describe the result data.

There are two functions to execute prepared and non-prepared queries
correspondingly: mysql_stmt_execute() and mysql_real_query(). Both functions
use the same function cli_read_query_result() to get information about fields
count, their names. So this part of result parsing is the same. But rows parsing
is absolutely different.

For non-prepared query mysql_fetch_row()->read_one_row() calls just set pointers
in array of rows to the certain values in read packet. As all values are in the
text format we have the array of pointers to null-terminated strings as the
output of the function.

But when binary data are parsed in mysql_stmt_fetch()->stmt_fetch_row() the
functions use information about field types from MYSQL_STMT::bind array.
For each element of this array
mysql_stmt_bind_result()->setup_one_fetch_function() sets the pointer to the
function which parses binary data of corresponding type to the buffer. For
example fetch_result_int32() is set up for MYSQL_TYPE_LONG data type.

So we have to develop new function mysql_stmt_execute_immediate() which would
mix mysql_real_query() and mysql_stmt_execute().

Use tests/stmt_execute_immediate.cc as the source of information about the
sequence of C API calls to send query and receive and parse binary answer.

stmt_execute_immediate.cc could be the part of mysql_client_test.c but the
customer disabled this test in his tree.

The new parameter --binary-protocol is added to mysqltest to allow communication
between client and server with binary protocol without "prepare" using
mysql_stmt_execute_immedate() function to send query.

=== modified file 'client/mysqltest.cc'
--- client/mysqltest.cc	2013-10-15 11:37:57 +0000
+++ client/mysqltest.cc	2014-09-09 12:25:45 +0000
@@ -87,7 +87,8 @@
 
 enum {
   OPT_PS_PROTOCOL=OPT_MAX_CLIENT_OPTION, OPT_SP_PROTOCOL,
-  OPT_CURSOR_PROTOCOL, OPT_VIEW_PROTOCOL, OPT_MAX_CONNECT_RETRIES,
+  OPT_CURSOR_PROTOCOL, OPT_BINARY_PROTOCOL,
+  OPT_VIEW_PROTOCOL, OPT_MAX_CONNECT_RETRIES,
   OPT_MAX_CONNECTIONS, OPT_MARK_PROGRESS, OPT_LOG_DIR,
   OPT_TAIL_LINES, OPT_RESULT_FORMAT_VERSION, OPT_TRACE_PROTOCOL,
   OPT_EXPLAIN_PROTOCOL, OPT_JSON_EXPLAIN_PROTOCOL
@@ -114,6 +115,7 @@
 static my_bool explain_protocol= 0, explain_protocol_enabled= 0;
 static my_bool json_explain_protocol= 0, json_explain_protocol_enabled= 0;
 static my_bool cursor_protocol= 0, cursor_protocol_enabled= 0;
+static my_bool binary_protocol= 0, binary_protocol_enabled= 0;;
 static my_bool parsing_disabled= 0;
 static my_bool display_result_vertically= FALSE, display_result_lower= FALSE,
   display_metadata= FALSE, display_result_sorted= FALSE;
@@ -6551,6 +6553,9 @@
   {"cursor-protocol", OPT_CURSOR_PROTOCOL, "Use cursors for prepared statements.",
    &cursor_protocol, &cursor_protocol, 0,
    GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+  {"binary-protocol", OPT_BINARY_PROTOCOL, "Use binary protocol without prepare query.",
+   &binary_protocol, &binary_protocol, 0,
+   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
   {"database", 'D', "Database to use.", &opt_db, &opt_db, 0,
    GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 #ifdef DBUG_OFF
@@ -7717,7 +7722,8 @@
   /*
     Prepare the query
   */
-  if (mysql_stmt_prepare(stmt, query, query_len))
+
+  if (!binary_protocol_enabled && mysql_stmt_prepare(stmt, query, query_len))
   {
     handle_error(command,  mysql_stmt_errno(stmt),
                  mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
@@ -7728,7 +7734,7 @@
     Get the warnings from mysql_stmt_prepare and keep them in a
     separate string
   */
-  if (!disable_warnings)
+  if (!binary_protocol && !disable_warnings)
     append_warnings(&ds_prepare_warnings, mysql);
 
   /*
@@ -7752,7 +7758,8 @@
   /*
     Execute the query
   */
-  if (mysql_stmt_execute(stmt))
+  if (binary_protocol_enabled ?
+        mysql_stmt_execute_immediate(stmt, query) : mysql_stmt_execute(stmt))
   {
     handle_error(command, mysql_stmt_errno(stmt),
                  mysql_stmt_error(stmt), mysql_stmt_sqlstate(stmt), ds);
@@ -8660,6 +8667,7 @@
   var_set_int("$EXPLAIN_PROTOCOL", explain_protocol);
   var_set_int("$JSON_EXPLAIN_PROTOCOL", json_explain_protocol);
   var_set_int("$CURSOR_PROTOCOL", cursor_protocol);
+  var_set_int("$BINARY_PROTOCOL", binary_protocol);
 
   var_set_int("$ENABLED_QUERY_LOG", 1);
   var_set_int("$ENABLED_ABORT_ON_ERROR", 1);
@@ -8687,8 +8695,12 @@
   var_set_string("MYSQLTEST_FILE", cur_file->file_name);
   init_re();
 
-  /* Cursor protcol implies ps protocol */
-  if (cursor_protocol)
+  if (cursor_protocol && binary_protocol)
+    die("Currently binary protocol without prepare query does not support "
+        "work with cursors, --cursor-protocol and --binary-protocol "
+        "options are mutually exclusive.");
+  /* Cursor and binary protcols implies ps protocol */
+  if (cursor_protocol || binary_protocol)
     ps_protocol= 1;
 
   ps_protocol_enabled= ps_protocol;
@@ -8698,6 +8710,7 @@
   explain_protocol_enabled= explain_protocol;
   json_explain_protocol_enabled= json_explain_protocol;
   cursor_protocol_enabled= cursor_protocol;
+  binary_protocol_enabled= binary_protocol;
 
   st_connection *con= connections;
 #ifdef EMBEDDED_LIBRARY

=== modified file 'include/mysql.h'
--- include/mysql.h	2013-05-12 06:24:46 +0000
+++ include/mysql.h	2014-09-09 12:25:45 +0000
@@ -674,6 +674,7 @@
 int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query,
                                unsigned long length);
 int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt);
+int STDCALL mysql_stmt_execute_immediate(MYSQL_STMT *stmt, const char *q);
 int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt);
 int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind_arg, 
                                     unsigned int column,
@@ -687,6 +688,9 @@
                                     enum enum_stmt_attr_type attr_type,
                                     void *attr);
 my_bool STDCALL mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
+my_bool STDCALL mysql_stmt_bind_immediate(MYSQL_STMT * stmt,
+                                          MYSQL_BIND * bnd,
+                                          size_t fields_count);
 my_bool STDCALL mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
 my_bool STDCALL mysql_stmt_close(MYSQL_STMT * stmt);
 my_bool STDCALL mysql_stmt_reset(MYSQL_STMT * stmt);

=== modified file 'include/mysql.h.pp'
--- include/mysql.h.pp	2013-02-12 07:47:19 +0000
+++ include/mysql.h.pp	2014-09-09 12:25:45 +0000
@@ -12,6 +12,7 @@
   COM_STMT_PREPARE, COM_STMT_EXECUTE, COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE,
   COM_STMT_RESET, COM_SET_OPTION, COM_STMT_FETCH, COM_DAEMON,
   COM_BINLOG_DUMP_GTID,
+  COM_STMT_EXECUTE_IMMEDIATE,
   COM_END
 };
 struct st_vio;
@@ -569,6 +570,7 @@
 int mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query,
                                unsigned long length);
 int mysql_stmt_execute(MYSQL_STMT *stmt);
+int mysql_stmt_execute_immediate(MYSQL_STMT *stmt, const char *q);
 int mysql_stmt_fetch(MYSQL_STMT *stmt);
 int mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *bind_arg,
                                     unsigned int column,
@@ -582,6 +584,9 @@
                                     enum enum_stmt_attr_type attr_type,
                                     void *attr);
 my_bool mysql_stmt_bind_param(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
+my_bool mysql_stmt_bind_immediate(MYSQL_STMT * stmt,
+                                  MYSQL_BIND * bnd,
+                                  size_t fields_count);
 my_bool mysql_stmt_bind_result(MYSQL_STMT * stmt, MYSQL_BIND * bnd);
 my_bool mysql_stmt_close(MYSQL_STMT * stmt);
 my_bool mysql_stmt_reset(MYSQL_STMT * stmt);

=== modified file 'include/mysql_com.h'
--- include/mysql_com.h	2014-03-26 10:11:16 +0000
+++ include/mysql_com.h	2014-09-09 12:25:45 +0000
@@ -74,6 +74,7 @@
   COM_STMT_PREPARE, COM_STMT_EXECUTE, COM_STMT_SEND_LONG_DATA, COM_STMT_CLOSE,
   COM_STMT_RESET, COM_SET_OPTION, COM_STMT_FETCH, COM_DAEMON,
   COM_BINLOG_DUMP_GTID,
+  COM_STMT_EXECUTE_IMMEDIATE,
   /* don't forget to update const char *command_name[] in sql_parse.cc */
 
   /* Must be last */

=== modified file 'include/sql_common.h'
--- include/sql_common.h	2013-08-14 03:57:21 +0000
+++ include/sql_common.h	2014-09-09 12:25:45 +0000
@@ -62,6 +62,7 @@
   MYSQL_FIELD * (*list_fields)(MYSQL *mysql);
   my_bool (*read_prepare_result)(MYSQL *mysql, MYSQL_STMT *stmt);
   int (*stmt_execute)(MYSQL_STMT *stmt);
+  int (*stmt_execute_immediate)(MYSQL_STMT *stmt, const char *query, size_t len);
   int (*read_binary_rows)(MYSQL_STMT *stmt);
   int (*unbuffered_fetch)(MYSQL *mysql, char **row);
   void (*free_embedded_thd)(MYSQL *mysql);

=== modified file 'libmysql/CMakeLists.txt'
--- libmysql/CMakeLists.txt	2014-08-22 10:02:24 +0000
+++ libmysql/CMakeLists.txt	2014-09-09 12:25:45 +0000
@@ -34,6 +34,7 @@
 mysql_affected_rows
 mysql_autocommit
 mysql_stmt_bind_param
+mysql_stmt_bind_immediate
 mysql_stmt_bind_result
 mysql_change_user
 mysql_character_set_name
@@ -48,6 +49,7 @@
 mysql_escape_string
 mysql_hex_string
 mysql_stmt_execute
+mysql_stmt_execute_immediate
 mysql_stmt_fetch
 mysql_stmt_fetch_column
 mysql_fetch_field

=== modified file 'libmysql/client_settings.h'
--- libmysql/client_settings.h	2013-06-20 15:16:00 +0000
+++ libmysql/client_settings.h	2014-09-09 12:25:45 +0000
@@ -57,6 +57,7 @@
 MYSQL_DATA * cli_read_rows(MYSQL *mysql,MYSQL_FIELD *mysql_fields,
 				   uint fields);
 int cli_stmt_execute(MYSQL_STMT *stmt);
+int cli_stmt_execute_immediate(MYSQL_STMT *stmt, const char *query, size_t len);
 int cli_read_binary_rows(MYSQL_STMT *stmt);
 int cli_unbuffered_fetch(MYSQL *mysql, char **row);
 const char * cli_read_statistics(MYSQL *mysql);

=== modified file 'libmysql/libmysql.c'
--- libmysql/libmysql.c	2014-08-22 13:31:49 +0000
+++ libmysql/libmysql.c	2014-09-09 12:25:45 +0000
@@ -75,6 +75,12 @@
 #endif /* __WIN__ */
 
 /*
+ Statemet ids begin with 1
+ (see THD::statement_id_counter, THD and Prepared_statement constructors)
+*/
+#define STMT_ID_UNDEFINED 0
+
+/*
   If allowed through some configuration, then this needs to
   be changed
 */
@@ -1658,37 +1664,15 @@
 }
 
 /*
-  Get result set metadata from reply to mysql_stmt_execute.
-  This is used mainly for SHOW commands, as metadata for these
-  commands is sent only with result set.
-  To be removed when all commands will fully support prepared mode.
+  Initialize stmt->fields with data from stmt->mysql->fields.
 */
 
-static void alloc_stmt_fields(MYSQL_STMT *stmt)
+static void init_stmt_fields(MYSQL_STMT *stmt)
 {
   MYSQL_FIELD *fields, *field, *end;
   MEM_ROOT *fields_mem_root= &stmt->extension->fields_mem_root;
   MYSQL *mysql= stmt->mysql;
 
-  DBUG_ASSERT(stmt->field_count);
-
-  free_root(fields_mem_root, MYF(0));
-
-  /*
-    Get the field information for non-select statements
-    like SHOW and DESCRIBE commands
-  */
-  if (!(stmt->fields= (MYSQL_FIELD *) alloc_root(fields_mem_root,
-						 sizeof(MYSQL_FIELD) *
-						 stmt->field_count)) ||
-      !(stmt->bind= (MYSQL_BIND *) alloc_root(fields_mem_root,
-					      sizeof(MYSQL_BIND) *
-					      stmt->field_count)))
-  {
-    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
-    return;
-  }
-
   for (fields= mysql->fields, end= fields+stmt->field_count,
 	 field= stmt->fields;
        field && fields < end; fields++, field++)
@@ -1729,6 +1713,38 @@
   }
 }
 
+/*
+  Get result set metadata from reply to mysql_stmt_execute.
+  This is used mainly for SHOW commands, as metadata for these
+  commands is sent only with result set.
+  To be removed when all commands will fully support prepared mode.
+*/
+
+static void alloc_stmt_fields(MYSQL_STMT *stmt)
+{
+  MEM_ROOT *fields_mem_root= &stmt->extension->fields_mem_root;
+
+  DBUG_ASSERT(stmt->field_count);
+
+  free_root(fields_mem_root, MYF(0));
+
+  /*
+    Get the field information for non-select statements
+    like SHOW and DESCRIBE commands
+  */
+  if (!(stmt->fields= (MYSQL_FIELD *) alloc_root(fields_mem_root,
+						 sizeof(MYSQL_FIELD) *
+						 stmt->field_count)) ||
+      !(stmt->bind= (MYSQL_BIND *) alloc_root(fields_mem_root,
+					      sizeof(MYSQL_BIND) *
+					      stmt->field_count)))
+  {
+    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+    return;
+  }
+
+  init_stmt_fields(stmt);
+}
 
 /**
   Update result set columns metadata if it was sent again in
@@ -2190,6 +2206,59 @@
 }
 
 /*
+  Send COM_STMT_EXECUTE_IMMEDIATE command with query string to server and
+  read command execution result.
+
+  SYNOPSIS
+    cli_stmt_execute_immediate()
+    stmt    statement handle
+    query   query string
+    len     query string len
+
+  RETURN VALUES
+    0	ok
+    1	error
+*/
+
+int cli_stmt_execute_immediate(MYSQL_STMT *stmt, const char *query, size_t len) {
+  MYSQL *mysql;
+  NET	*net;
+  my_bool res;
+  DBUG_ENTER("cli_stmt_execute_immediate");
+  mysql= stmt->mysql;
+  net= &mysql->net;
+
+  /*
+    The last parameter of advanced_command() should be NULL to enable command
+    resending after reconnect in cli_advanced_command()
+    (see stmt_skip local variable).
+  */
+  res= MY_TEST((*mysql->methods->advanced_command)(mysql,
+                                                   COM_STMT_EXECUTE_IMMEDIATE,
+						   0, 0,
+                                                   (uchar*)query, len,
+                                                   1, NULL) ||
+               (*mysql->methods->read_query_result)(mysql));
+
+  stmt->affected_rows= mysql->affected_rows;
+  stmt->server_status= mysql->server_status;
+  stmt->insert_id= mysql->insert_id;
+  if (res)
+  {
+    /*
+      Don't set stmt error if stmt->mysql is NULL, as the error in this case
+      has already been set by mysql_prune_stmt_list().
+    */
+    if (stmt->mysql)
+      set_stmt_errmsg(stmt, net);
+    DBUG_RETURN(1);
+  }
+  else if (mysql->status == MYSQL_STATUS_GET_RESULT)
+    stmt->mysql->status= MYSQL_STATUS_STATEMENT_GET_RESULT;
+  DBUG_RETURN(0);
+}
+
+/*
   Read one row from buffered result set.  Result set is created by prior
   call to mysql_stmt_store_result().
   SYNOPSIS
@@ -2573,6 +2642,108 @@
   DBUG_RETURN(MY_TEST(stmt->last_errno));
 }
 
+/**
+  Reallocate and initialize stmt->fields with values from
+  stmt->mysql->fields.
+
+  @arguments     stmt - statement header
+
+  @retval TRUE   error
+  @retval FALSE  success
+*/
+
+static int reinit_stmt_fields(MYSQL_STMT *stmt)
+{
+  MEM_ROOT *fields_mem_root;
+  stmt->field_count= stmt->mysql->field_count;
+  fields_mem_root= &stmt->extension->fields_mem_root;
+
+  DBUG_ASSERT(stmt->field_count);
+
+  free_root(fields_mem_root, MYF(0));
+
+  if (!(stmt->fields= (MYSQL_FIELD *) alloc_root(fields_mem_root,
+                                                 sizeof(MYSQL_FIELD) *
+                                                 stmt->field_count)))
+  {
+    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+    return 1;
+  }
+
+  init_stmt_fields(stmt);
+
+  return 0;
+}
+
+/*
+  This is the analogue of mysql_stmt_execute() but allows to execute
+  queries without "prepare" step. The difference with mysql_real_query is
+  that the ansewer
+
+  SYNOPSIS
+    mysql_stmt_execute_immediate()
+    stmt  statement handle. The handle must be created
+          with mysql_stmt_init(). The result data can be
+	  bound to variables with mysql_stmt_bind_immediate() function
+	  after mysql_stmt_execute_immediate() call.
+
+  DESCRIPTION
+    This function sends COM_STMT_EXECUTE_IMMEDIATE to server with query
+    string. The query is executed on server and the result data is sent
+    with binary protocol which can be then parsed with the same way as
+    for mysql_stmt_execute() function. To bind result to variables use
+    mysql_stmt_bind_immediate() instead of mysql_stmt_bind_result().
+
+    There is no possibility to use cursors with mysql_stmt_attr_set() as
+    server does not support such feature.
+
+    As for the rest this function is like mysql_stmt_execute().
+    See description of mysql_stmt_execute() for more details.
+
+  RETURN
+    0   success
+    1   error, message can be retrieved with mysql_stmt_error().
+*/
+
+int STDCALL mysql_stmt_execute_immediate(MYSQL_STMT *stmt, const char *q)
+{
+  MYSQL *mysql;
+  DBUG_ENTER("mysql_stmt_execute_immediate");
+  mysql= stmt->mysql;
+
+  if (!mysql)
+  {
+    set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  stmt->bind_param_done= stmt->bind_result_done= FALSE;
+  stmt->param_count= stmt->field_count= 0;
+  stmt->bind= stmt->params= NULL;
+  /*
+    Set statement id to "undefined" to disable sending COM_STMT_CLOSE
+    in mysql_stmt_close().
+  */
+  stmt->stmt_id= STMT_ID_UNDEFINED;
+  free_root(&stmt->mem_root, MYF(MY_KEEP_PREALLOC));
+  free_root(&stmt->extension->fields_mem_root, MYF(0));
+
+  stmt->state= MYSQL_STMT_PREPARE_DONE;
+  if (reset_stmt_handle(stmt, RESET_STORE_RESULT | RESET_CLEAR_ERROR))
+    DBUG_RETURN(1);
+
+  if (mysql->methods->stmt_execute_immediate(stmt, q, strlen(q)))
+    DBUG_RETURN(1);
+
+  stmt->state= MYSQL_STMT_EXECUTE_DONE;
+  if (mysql->field_count)
+  {
+    reinit_stmt_fields(stmt);
+    update_stmt_fields(stmt);
+    prepare_to_fetch_result(stmt);
+  }
+  DBUG_RETURN(MY_TEST(stmt->last_errno));
+};
 
 /*
   Return total parameters count in the statement
@@ -2914,6 +3085,57 @@
   DBUG_RETURN(0);
 }
 
+/*
+  Setup the bind buffers for resultset processing for
+  mysql_stmt_execute_immediate() call. This function must
+  be invoken only after mysql_stmt_execute_immediate call.
+
+  SYNOPSIS
+    mysql_stmt_bind_immediate()
+    stmt          statement handle. The handle must be created
+                  with mysql_stmt_init().
+    my_bind       the pointer to the array with bind information.
+    fields_count  the number of elements in my_bind array
+
+  DESCRIPTION
+    This function is used to bind buffers for resultset processing in the
+    pair with mysql_stmt_execute_immediate(). This is analogue of
+    mysql_stmt_bind_result(). But mysql_stmt_bind_result() assumes some
+    fields of MYSQL_BIND object are initialized in mysql_stmt_prepare().
+    As "prepare" step is skipped for mysql_stmt_execute_immediate() those
+    fields need to be initialized somewhere. mysql_stmt_bind_immediate()
+    initializes those fields and invokes mysql_stmt_bind_result(). This
+    function must be invoked only after mysql_stmt_execute_immediate call.
+
+  RETURN
+    0   success
+    1   error, message can be retrieved with mysql_stmt_error().
+*/
+
+my_bool STDCALL mysql_stmt_bind_immediate(MYSQL_STMT *stmt,
+                                            MYSQL_BIND *my_bind,
+					    size_t fields_count)
+{
+  DBUG_ENTER("mysql_stmt_bind_immediate");
+  stmt->field_count = fields_count;
+  stmt->param_count = 0;
+  stmt->params = NULL;
+  /*
+    alloc_root will return valid address even in case when param_count
+    and field_count are zero. Thus we should never rely on stmt->bind
+    or stmt->params when checking for existence of placeholders or
+    result set.
+  */
+  if (!(stmt->bind = (MYSQL_BIND *) alloc_root(&stmt->mem_root,
+					       sizeof(MYSQL_BIND)*
+                                               stmt->field_count)))
+  {
+    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  DBUG_RETURN(mysql_stmt_bind_result(stmt, my_bind));
+}
 
 /********************************************************************
  Long data implementation
@@ -3983,6 +4205,8 @@
                          (uint) param->buffer_type));
     DBUG_RETURN(TRUE);
   }
+  if (!field)
+    DBUG_RETURN(FALSE);
   if (! is_binary_compatible(param->buffer_type, field->type))
     param->fetch_result= fetch_result_with_conversion;
 
@@ -4096,7 +4320,8 @@
        param++, field++)
   {
     DBUG_PRINT("info",("buffer_type: %u  field_type: %u",
-                       (uint) param->buffer_type, (uint) field->type));
+                       (uint) param->buffer_type,
+                       stmt->fields ? (uint) field->type : 0));
     /*
       Set param->is_null to point to a dummy variable if it's not set.
       This is to make the execute code easier
@@ -4113,12 +4338,12 @@
     param->param_number= param_count++;
     param->offset= 0;
 
-    if (setup_one_fetch_function(param, field))
+    if (setup_one_fetch_function(param, stmt->fields ? field : 0))
     {
       strmov(stmt->sqlstate, unknown_sqlstate);
       sprintf(stmt->last_error,
               ER(stmt->last_errno= CR_UNSUPPORTED_PARAM_TYPE),
-              field->type, param_count);
+              stmt->fields ? field->type : 0, param_count);
       DBUG_RETURN(1);
     }
   }
@@ -4483,6 +4708,14 @@
     */
     MYSQL_BIND  *my_bind, *end;
     MYSQL_FIELD *field;
+    if (!stmt->bind &&
+        !(stmt->bind = (MYSQL_BIND *) alloc_root(&stmt->mem_root,
+                                                 sizeof(MYSQL_BIND)*
+                                                 stmt->field_count)))
+    {
+      set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+      DBUG_RETURN(1);
+    }
     memset(stmt->bind, 0, sizeof(*stmt->bind) * stmt->field_count);
 
     for (my_bind= stmt->bind, end= my_bind + stmt->field_count,
@@ -4725,10 +4958,13 @@
           *mysql->unbuffered_fetch_owner= TRUE;
         mysql->status= MYSQL_STATUS_READY;
       }
-      int4store(buff, stmt->stmt_id);
-      if ((rc= stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt)))
+      if (stmt->stmt_id != STMT_ID_UNDEFINED)
       {
-        set_stmt_errmsg(stmt, &mysql->net);
+        int4store(buff, stmt->stmt_id);
+        if ((rc= stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt)))
+        {
+          set_stmt_errmsg(stmt, &mysql->net);
+        }
       }
     }
   }

=== modified file 'libmysql/libmysql.def'
--- libmysql/libmysql.def	2013-08-13 21:11:09 +0000
+++ libmysql/libmysql.def	2014-09-09 12:25:45 +0000
@@ -9,6 +9,7 @@
 	mysql_autocommit
 	mysql_stmt_bind_param
 	mysql_stmt_bind_result
+	mysql_stmt_bind_immediate
 	mysql_change_user
 	mysql_character_set_name
 	mysql_close
@@ -22,6 +23,7 @@
 	mysql_escape_string
 	mysql_hex_string
 	mysql_stmt_execute
+	mysql_stmt_execute_immediate
 	mysql_stmt_fetch
 	mysql_stmt_fetch_column
 	mysql_fetch_field

=== modified file 'libmysqld/lib_sql.cc'
--- libmysqld/lib_sql.cc	2014-08-22 10:02:24 +0000
+++ libmysqld/lib_sql.cc	2014-09-09 12:25:45 +0000
@@ -354,6 +354,13 @@
   DBUG_RETURN(0);
 }
 
+static int emb_stmt_execute_immediate(MYSQL_STMT *stmt, const char *, size_t)
+{
+  DBUG_ENTER("emb_stmt_execute_immediate");
+  set_stmt_error(stmt, CR_NOT_IMPLEMENTED, unknown_sqlstate, NULL);
+  DBUG_RETURN(1);
+}
+
 int emb_read_binary_rows(MYSQL_STMT *stmt)
 {
   MYSQL_DATA *data;
@@ -461,6 +468,7 @@
   emb_list_fields,
   emb_read_prepare_result,
   emb_stmt_execute,
+  emb_stmt_execute_immediate,
   emb_read_binary_rows,
   emb_unbuffered_fetch,
   emb_free_embedded_thd,

=== modified file 'mysql-test/mysql-test-run.pl'
--- mysql-test/mysql-test-run.pl	2014-08-22 13:31:49 +0000
+++ mysql-test/mysql-test-run.pl	2014-09-09 12:25:45 +0000
@@ -192,6 +192,7 @@
 my $opt_ps_protocol;
 my $opt_sp_protocol;
 my $opt_cursor_protocol;
+my $opt_binary_protocol;
 my $opt_view_protocol;
 my $opt_trace_protocol;
 my $opt_explain_protocol;
@@ -990,6 +991,7 @@
   resfile_global("sp-protocol", $opt_sp_protocol ? 1 : 0);
   resfile_global("view-protocol", $opt_view_protocol ? 1 : 0);
   resfile_global("cursor-protocol", $opt_cursor_protocol ? 1 : 0);
+  resfile_global("binary-protocol", $opt_binary_protocol ? 1 : 0);
   resfile_global("ssl", $opt_ssl ? 1 : 0);
   resfile_global("compress", $opt_compress ? 1 : 0);
   resfile_global("parallel", $opt_parallel);
@@ -1043,6 +1045,7 @@
              'explain-protocol'         => \$opt_explain_protocol,
              'json-explain-protocol'    => \$opt_json_explain_protocol,
              'cursor-protocol'          => \$opt_cursor_protocol,
+             'binary-protocol'          => \$opt_binary_protocol,
              'ssl|with-openssl'         => \$opt_ssl,
              'skip-ssl'                 => \$opt_skip_ssl,
              'compress'                 => \$opt_compress,
@@ -2492,6 +2495,11 @@
                            "$basedir/tests/bug25714");
   $ENV{'MYSQL_BUG25714'}=  native_path($exe_bug25714);
 
+  my $exe_stmt_execute_immediate=
+      mtr_exe_maybe_exists(vs_config_dirs('tests', 'stmt_execute_immediate'),
+                           "$basedir/tests/stmt_execute_immediate");
+  $ENV{'MYSQL_STMT_EXECUTE_IMMEDIATE'}=  native_path($exe_stmt_execute_immediate);
+
   # ----------------------------------------------------
   # mysql_fix_privilege_tables.sql
   # ----------------------------------------------------
@@ -5927,6 +5935,10 @@
     mtr_add_arg($args, "--cursor-protocol");
   }
 
+  if ( $opt_binary_protocol )
+  {
+    mtr_add_arg($args, "--binary-protocol");
+  }
 
   mtr_add_arg($args, "--timer-file=%s/log/timer", $opt_vardir);
 
@@ -6478,6 +6490,9 @@
   ps-protocol           Use the binary protocol between client and server
   cursor-protocol       Use the cursor protocol between client and server
                         (implies --ps-protocol)
+  binary-protocol       Use the binary protocol between client and server
+                        without prepare stage (mysql_stmt_execute_immediate())
+                        (implies --ps-protocol)
   view-protocol         Create a view to execute all non updating queries
   opt-trace-protocol    Print optimizer trace
   explain-protocol      Run 'EXPLAIN EXTENDED' on all SELECT, INSERT,

=== added file 'mysql-test/r/stmt_execute_immediate.result'
--- mysql-test/r/stmt_execute_immediate.result	1970-01-01 00:00:00 +0000
+++ mysql-test/r/stmt_execute_immediate.result	2014-09-09 12:25:45 +0000
@@ -0,0 +1,64 @@
+Testing drop, create, insert:
+Insert id: 3, affected rows: 1
+
+Test for select with result storing:
+Iteration number 0
+Rows count: 0, fields count: 3
+binary: 1, Audi, 52642
+Iteration number 1
+Rows count: 0, fields count: 3
+binary: 1, Audi, 52642
+binary: 2, Hummer, 41400
+Iteration number 2
+Rows count: 0, fields count: 3
+binary: 1, Audi, 52642
+binary: 2, Hummer, 41400
+binary: 3, Volkswagen, 21600
+
+Test for multiple results with result storing:
+Rows count: 0, fields count: 3
+binary: 1, Audi, 52642
+Rows count: 0, fields count: 3
+binary: 2, Hummer, 41400
+Rows count: 0, fields count: 3
+binary: 3, Volkswagen, 21600
+
+Test for select without result storing:
+Iteration number 0
+Rows count: 1, fields count: 3
+binary: 1, Audi, 52642
+Iteration number 1
+Rows count: 2, fields count: 3
+binary: 1, Audi, 52642
+binary: 2, Hummer, 41400
+Iteration number 2
+Rows count: 3, fields count: 3
+binary: 1, Audi, 52642
+binary: 2, Hummer, 41400
+binary: 3, Volkswagen, 21600
+
+Test for multiple results without result storing:
+Rows count: 1, fields count: 3
+binary: 1, Audi, 52642
+Rows count: 1, fields count: 3
+binary: 2, Hummer, 41400
+Rows count: 1, fields count: 3
+binary: 3, Volkswagen, 21600
+
+Test for select if the number and the type of fields are unknown before query execution:
+bind col[0]: buffer_type: 254, buffer_length: 12
+bind col[1]: buffer_type: 254, buffer_length: 11
+bind col[2]: buffer_type: 254, buffer_length: 12
+fetch col[0]: buffer_type: 254, buffer_length: 12, buffer: 1
+fetch col[1]: buffer_type: 254, buffer_length: 11, buffer: Audi
+fetch col[2]: buffer_type: 254, buffer_length: 12, buffer: 52642
+fetch col[0]: buffer_type: 254, buffer_length: 12, buffer: 2
+fetch col[1]: buffer_type: 254, buffer_length: 11, buffer: Hummer
+fetch col[2]: buffer_type: 254, buffer_length: 12, buffer: 41400
+fetch col[0]: buffer_type: 254, buffer_length: 12, buffer: 3
+fetch col[1]: buffer_type: 254, buffer_length: 11, buffer: Volkswagen
+fetch col[2]: buffer_type: 254, buffer_length: 12, buffer: 21600
+
+Test for error:
+Errno: 1146, error text: Table 'test.bars' doesn't exist
+Errno: 1064, error text: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'SELEC * FROM bars' at line 1

=== added file 'mysql-test/t/stmt_execute_immediate.test'
--- mysql-test/t/stmt_execute_immediate.test	1970-01-01 00:00:00 +0000
+++ mysql-test/t/stmt_execute_immediate.test	2014-09-09 12:25:45 +0000
@@ -0,0 +1,7 @@
+ # Check that path to the specific test program has been setup
+if (!$MYSQL_STMT_EXECUTE_IMMEDIATE)
+{
+  skip Need stmt_execute_immediate test program;
+}
+
+--exec $MYSQL_STMT_EXECUTE_IMMEDIATE $MASTER_MYPORT

=== modified file 'sql-common/client.c'
--- sql-common/client.c	2014-08-22 13:31:49 +0000
+++ sql-common/client.c	2014-09-09 12:25:45 +0000
@@ -1916,6 +1916,7 @@
   ,cli_list_fields,                            /* list_fields */
   cli_read_prepare_result,                     /* read_prepare_result */
   cli_stmt_execute,                            /* stmt_execute */
+  cli_stmt_execute_immediate,                              /* stmt_execute_immediate */
   cli_read_binary_rows,                        /* read_binary_rows */
   cli_unbuffered_fetch,                        /* unbuffered_fetch */
   NULL,                                        /* free_embedded_thd */

=== modified file 'sql/sql_parse.cc'
--- sql/sql_parse.cc	2014-08-22 10:02:24 +0000
+++ sql/sql_parse.cc	2014-09-09 12:25:45 +0000
@@ -168,6 +168,7 @@
   { C_STRING_WITH_LEN("Fetch") },
   { C_STRING_WITH_LEN("Daemon") },
   { C_STRING_WITH_LEN("Binlog Dump GTID") },
+  { C_STRING_WITH_LEN("Query With Binary Answer") },
   { C_STRING_WITH_LEN("Error") }  // Last command number
 };
 
@@ -1226,6 +1227,9 @@
 bool dispatch_command(enum enum_server_command command, THD *thd,
 		      char* packet, uint packet_length)
 {
+  bool query_statement = (command == COM_STMT_EXECUTE_IMMEDIATE);
+  if (command == COM_STMT_EXECUTE_IMMEDIATE)
+    command = COM_QUERY;
   NET *net= &thd->net;
   bool error= 0;
   DBUG_ENTER("dispatch_command");
@@ -1429,6 +1433,10 @@
     if (parser_state.init(thd, thd->query(), thd->query_length()))
       break;
 
+    Protocol *save_protocol= thd->protocol;
+    if (query_statement)
+      thd->protocol= &thd->protocol_binary;
+
     mysql_parse(thd, thd->query(), thd->query_length(), &parser_state);
 
     while (!thd->killed && (parser_state.m_lip.found_semicolon != NULL) &&
@@ -1507,6 +1515,7 @@
       mysql_parse(thd, beginning_of_next_stmt, length, &parser_state);
     }
 
+    thd->protocol = save_protocol;
     DBUG_PRINT("info",("query ready"));
     break;
   }

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2013-10-08 06:03:07 +0000
+++ tests/CMakeLists.txt	2014-09-09 12:25:45 +0000
@@ -25,6 +25,10 @@
   ADD_EXECUTABLE(bug25714 bug25714.c)
   TARGET_LINK_LIBRARIES(bug25714 perconaserverclient)
   SET_TARGET_PROPERTIES(bug25714 PROPERTIES LINKER_LANGUAGE CXX)
+
+  ADD_EXECUTABLE(stmt_execute_immediate stmt_execute_immediate.cc)
+  TARGET_LINK_LIBRARIES(stmt_execute_immediate perconaserverclient)
+  SET_TARGET_PROPERTIES(stmt_execute_immediate PROPERTIES LINKER_LANGUAGE CXX)
 ENDIF()
 
 INSTALL(TARGETS mysql_client_test DESTINATION ${INSTALL_BINDIR} COMPONENT Test)

=== added file 'tests/stmt_execute_immediate.cc'
--- tests/stmt_execute_immediate.cc	1970-01-01 00:00:00 +0000
+++ tests/stmt_execute_immediate.cc	2014-09-09 12:25:45 +0000
@@ -0,0 +1,259 @@
+#include <my_global.h>
+#include <my_sys.h>
+#include <mysql.h>
+#include <string.h>
+
+void finish_with_error(MYSQL *con)
+{
+  fprintf(stderr, "%s\n", mysql_error(con));
+  mysql_close(con);
+  exit(1);
+}
+
+int main(int argc, char **argv)
+{
+  MYSQL con;
+  MYSQL_BIND stmt_result[3];
+  int id;
+  char name[255];
+  int price;
+  my_bool is_null[3];
+  MYSQL_STMT    *stmt;
+  MYSQL_RES *res= NULL;
+
+  if (argc != 2 || !strcmp(argv[1], "--help"))
+  {
+    fprintf(stderr, "This program is a part of the MySQL test suite. "
+            "It is not intended to be executed directly by a user.\n");
+    return -1;
+  }
+
+  MY_INIT(argv[0]);
+
+  memset(stmt_result, 0, sizeof(stmt_result));
+
+  stmt_result[0].buffer_type    = MYSQL_TYPE_LONG;
+  stmt_result[0].buffer         = (void *) &id;
+  stmt_result[0].is_unsigned    = 0;
+  stmt_result[0].is_null        = &is_null[0];
+  stmt_result[0].length         = 0;
+
+  stmt_result[1].buffer_type    = MYSQL_TYPE_STRING;
+  stmt_result[1].buffer         = (void *) name;
+  stmt_result[1].is_unsigned    = 0;
+  stmt_result[1].is_null        = &is_null[0];
+  stmt_result[1].buffer_length  = sizeof(name) - 1;
+  stmt_result[1].length         = 0;
+
+  stmt_result[2].buffer_type    = MYSQL_TYPE_LONG;
+  stmt_result[2].buffer         = (void *) &price;
+  stmt_result[2].is_unsigned    = 0;
+  stmt_result[2].is_null        = &is_null[0];
+  stmt_result[2].length         = 0;
+
+  mysql_init(&con);
+
+  if (mysql_real_connect(&con, "127.0.0.1", "root", "",
+          "test", atoi(argv[1]), NULL, 0) == NULL)
+    finish_with_error(&con);
+
+  stmt = mysql_stmt_init(&con);
+  /********************************************************
+   Test #1: Test for queries which do not contain resultset.
+  *********************************************************/
+  printf("Testing drop, create, insert:\n");
+  if (!stmt)
+    finish_with_error(&con);
+
+  if (mysql_stmt_execute_immediate(stmt, "DROP TABLE IF EXISTS Cars"))
+    finish_with_error(&con);
+
+  if (mysql_stmt_execute_immediate(stmt, "CREATE TABLE Cars(Id INT AUTO_INCREMENT PRIMARY KEY, Name TEXT, Price INT)"))
+    finish_with_error(&con);
+
+  if (mysql_stmt_execute_immediate(stmt, "INSERT INTO Cars (Name, price) VALUES('Audi',52642)"))
+    finish_with_error(&con);
+
+  if (mysql_stmt_execute_immediate(stmt, "INSERT INTO Cars (Name, price) VALUES('Hummer',41400)"))
+    finish_with_error(&con);
+
+  if (mysql_stmt_execute_immediate(stmt, "INSERT INTO Cars (Name, price) VALUES('Volkswagen',21600)"))
+    finish_with_error(&con);
+
+  my_ulonglong insert_id = mysql_stmt_insert_id(stmt);
+  my_ulonglong affected_rows = mysql_stmt_affected_rows(stmt);
+
+  printf("Insert id: %llu, affected rows: %llu\n", insert_id, affected_rows);
+
+  if (mysql_stmt_execute_immediate(stmt, "DROP PROCEDURE IF EXISTS simpleproc"))
+    finish_with_error(&con);
+  if (mysql_stmt_execute_immediate(stmt, "CREATE PROCEDURE simpleproc () "
+                                         "BEGIN "
+                                         "SELECT * FROM Cars WHERE Id = 1; "
+                                         "SELECT * FROM Cars WHERE Id = 2; "
+                                         "SELECT * FROM Cars WHERE Id = 3; "
+                                         "END"))
+    finish_with_error(&con);
+
+  for (int need_store_result = 0; need_store_result < 2; ++need_store_result) {
+    /************************************************************
+     Test #2: Test for queries which have one resultset. The test
+     has two variants - with and without storing result on
+     client-side.
+     *************************************************************/
+    printf("\nTest for select %s:\n", need_store_result ?
+                                      "without result storing" :
+				      "with result storing");
+    for (unsigned i = 0; i < 3; ++i) {
+      char query[100];
+      snprintf(query,
+               sizeof(query) - 1,
+	       "SELECT * FROM Cars WHERE Id <= %u", i + 1);
+      printf("Iteration number %u\n", i);
+      if (mysql_stmt_execute_immediate(stmt, query))
+        finish_with_error(&con);
+      if (mysql_stmt_bind_immediate(stmt,
+            stmt_result, sizeof(stmt_result)/sizeof(stmt_result[0])) != 0)
+        finish_with_error(&con);
+      if (need_store_result && mysql_stmt_store_result(stmt))
+        finish_with_error(&con);
+      my_ulonglong num_rows = mysql_stmt_num_rows(stmt);
+      unsigned int field_count = mysql_stmt_field_count(stmt);
+      printf("Rows count: %llu, fields count: %d\n", num_rows, field_count);
+      while(!mysql_stmt_fetch (stmt))
+        printf("binary: %d, %s, %d\n", id, name, price);
+      mysql_stmt_free_result(stmt);
+    }
+    /*****************************************************************
+     Test #3: Test for queries which have multiple resultset. The test
+     has two variants - with and without storing result on
+     client-side.
+     *****************************************************************/
+    printf("\nTest for multiple results %s:\n",
+           need_store_result ?
+           "without result storing" : "with result storing");
+    if (mysql_stmt_execute_immediate(stmt, "CALL simpleproc()"))
+      finish_with_error(&con);
+    do {
+      unsigned int field_count = mysql_stmt_field_count(stmt);
+      if (field_count) {
+        if (mysql_stmt_bind_immediate(stmt,
+	      stmt_result, sizeof(stmt_result)/sizeof(stmt_result[0])) != 0)
+          finish_with_error(&con);
+        if (need_store_result && mysql_stmt_store_result(stmt))
+          finish_with_error(&con);
+        my_ulonglong num_rows = mysql_stmt_num_rows(stmt);
+        printf("Rows count: %llu, fields count: %d\n", num_rows, field_count);
+        while(!mysql_stmt_fetch (stmt))
+          printf("binary: %d, %s, %d\n", id, name, price);
+        mysql_stmt_free_result(stmt);
+      }
+    } while(mysql_stmt_next_result(stmt) == 0);
+  }
+  /*************************************************************
+   Test #4: The case when the number of fields is unknown before
+   query execution.
+  **************************************************************/
+  printf("\nTest for select if the number and the type of fields "
+         "are unknown before query execution:\n");
+  if (mysql_stmt_execute_immediate(stmt, "SELECT * FROM Cars"))
+      finish_with_error(&con);
+  {
+    my_bool one= 1;
+    if (mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one))
+      finish_with_error(&con);
+  }
+  if (mysql_stmt_field_count(stmt)) {
+    if (mysql_stmt_store_result(stmt))
+      finish_with_error(&con);
+    if ((res= mysql_stmt_result_metadata(stmt)) != NULL) {
+      MYSQL_BIND *my_bind;
+      my_bool *is_null;
+      ulong *length;
+      uint i;
+      MYSQL_FIELD *fields;
+      uint num_fields;
+
+      /* Take the column count from meta info */
+      fields= mysql_fetch_fields(res);
+      num_fields= mysql_num_fields(res);
+
+      my_bind= (MYSQL_BIND*) my_malloc(num_fields * sizeof(MYSQL_BIND),
+                                       MYF(MY_WME | MY_FAE | MY_ZEROFILL));
+      length= (ulong*) my_malloc(num_fields * sizeof(ulong),
+                                 MYF(MY_WME | MY_FAE));
+      is_null= (my_bool*) my_malloc(num_fields * sizeof(my_bool),
+                                    MYF(MY_WME | MY_FAE));
+
+      /* Allocate data for the result of each field */
+      for (i= 0; i < num_fields; i++)
+      {
+        uint max_length= fields[i].max_length + 1;
+        my_bind[i].buffer_type= MYSQL_TYPE_STRING;
+        my_bind[i].buffer= my_malloc(max_length, MYF(MY_WME | MY_FAE));
+        my_bind[i].buffer_length= max_length;
+        my_bind[i].is_null= &is_null[i];
+        my_bind[i].length= &length[i];
+
+        printf("bind col[%d]: buffer_type: %d, buffer_length: %lu\n",
+	       i, my_bind[i].buffer_type, my_bind[i].buffer_length);
+      }
+      /*
+       It is safe to use mysql_stmt_bind_result() instead of
+       mysql_stmt_bind_immediate() here as all neccessary
+       data in stmt has been initialized already in
+       mysql_stmt_store_result() as STMT_ATTR_UPDATE_MAX_LENGTH
+       attribute was set to one
+       (see also stmt->update_max_length description).
+      */
+      if (mysql_stmt_bind_result(stmt, my_bind))
+        finish_with_error(&con);
+
+      while (mysql_stmt_fetch(stmt) == 0)
+        for (i= 0; i < num_fields; i++)
+          printf("fetch col[%d]: buffer_type: %d, buffer_length: %lu, "
+	         "buffer: %s\n",
+	         i, my_bind[i].buffer_type, my_bind[i].buffer_length,
+		 (char *)my_bind[i].buffer);
+
+      for (i= 0; i < num_fields; i++)
+      {
+        /* Free data for output */
+        my_free(my_bind[i].buffer);
+      }
+      /* Free array with bind structs, lengths and NULL flags */
+      my_free(my_bind);
+      my_free(length);
+      my_free(is_null);
+    }
+  }
+  {
+    my_bool zero= 0;
+    if (mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &zero))
+      finish_with_error(&con);
+  }
+  mysql_stmt_free_result(stmt);
+
+  /************************************************************
+   Test #5: Test for errors.
+  *************************************************************/
+  printf("\nTest for error:\n");
+  if (!mysql_stmt_execute_immediate(stmt, "SELECT * FROM bars")) {
+    printf("Must be error!\n");
+    return 1;
+  }
+  printf("Errno: %u, error text: %s\n", mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
+  if (!mysql_stmt_execute_immediate(stmt, "SELEC * FROM bars")) {
+    printf("Must be error!\n");
+    return 1;
+  }
+  printf("Errno: %u, error text: %s\n", mysql_stmt_errno(stmt), mysql_stmt_error(stmt));
+
+  mysql_stmt_execute_immediate(stmt, "DROP PROCEDURE simpleproc");
+  mysql_stmt_execute_immediate(stmt, "DROP TABLE Cars");
+
+  mysql_stmt_close(stmt);
+
+  mysql_close(&con);
+  return 0;
+}