metrics have been added

1 files changed, 4633 insertions, 0 deletions

diff --git a/contrib/libs/libmysql_r/libmysql/libmysql.cc b/contrib/libs/libmysql_r/libmysql/libmysql.cc
new file mode 100644
index 00000000000..91ecab29e2a
--- /dev/null
+++ b/contrib/libs/libmysql_r/libmysql/libmysql.cc
@@ -0,0 +1,4633 @@
+/* Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License, version 2.0,
+   as published by the Free Software Foundation.
+
+   This program is also distributed with certain software (including
+   but not limited to OpenSSL) that is licensed under separate terms,
+   as designated in a particular file or component or in included license
+   documentation.  The authors of MySQL hereby grant you an additional
+   permission to link the program and your derivative works with the
+   separately licensed software that they have included with MySQL.
+
+   Without limiting anything contained in the foregoing, this file,
+   which is part of C Driver for MySQL (Connector/C), is also subject to the
+   Universal FOSS Exception, version 1.0, a copy of which can be found at
+   http://oss.oracle.com/licenses/universal-foss-exception.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License, version 2.0, for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA */
+
+#include "my_config.h"
+
+#include <fcntl.h>
+#include <limits.h>
+#include <math.h>
+#include <sys/types.h>
+
+#include "m_ctype.h"
+#include "m_string.h"
+#include "my_alloc.h"
+#include "my_sys.h"
+#include "my_time.h"
+#include "mysys_err.h"
+#ifndef _WIN32
+#include <netdb.h>
+#endif
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <time.h>
+
+#include "errmsg.h"
+#include "my_byteorder.h"
+#include "my_compiler.h"
+#include "my_dbug.h"
+#include "my_double2ulonglong.h"
+#include "my_inttypes.h"
+#include "my_io.h"
+#include "my_macros.h"
+#include "my_pointer_arithmetic.h"
+#include "my_thread_local.h"
+#include "mysql.h"
+#include "mysql/service_mysql_alloc.h"
+#include "mysql_com.h"
+#include "mysql_version.h"
+#include "mysqld_error.h"
+#include "template_utils.h"
+#include "violite.h"
+
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+#ifdef HAVE_SYS_SELECT_H
+#include <sys/select.h>
+#endif
+#ifdef HAVE_POLL
+#include <poll.h>
+#endif
+#ifdef HAVE_SYS_UN_H
+#include <sys/un.h>
+#endif
+#if !defined(_WIN32)
+#include "my_thread.h" /* because of signal()	*/
+#endif
+#ifndef INADDR_NONE
+#define INADDR_NONE -1
+#endif
+
+#include <memory>
+
+#include "client_settings.h"
+#include "mysql_trace.h"
+#include "sql_common.h"
+
+/*
+  Temporary replacement for COM_SHUTDOWN. This will be removed once
+  mysql_shutdown C API is removed.
+*/
+#define COM_SHUTDOWN_DEPRECATED 8
+static void append_wild(char *to, char *end, const char *wild);
+
+static bool mysql_client_init = 0;
+static bool org_my_init_done = 0;
+
+struct MYSQL_STMT_EXT {
+  MEM_ROOT fields_mem_root;
+};
+
+/*
+  Initialize the MySQL client library
+
+  SYNOPSIS
+    mysql_server_init()
+
+  NOTES
+    Should be called before doing any other calls to the MySQL
+    client library to initialize thread specific variables etc.
+    It's called by mysql_init() to ensure that things will work for
+    old not threaded applications that doesn't call mysql_server_init()
+    directly.
+
+  RETURN
+    0  ok
+    1  could not initialize environment (out of memory or thread keys)
+*/
+
+int STDCALL mysql_server_init(int argc MY_ATTRIBUTE((unused)),
+                              char **argv MY_ATTRIBUTE((unused)),
+                              char **groups MY_ATTRIBUTE((unused))) {
+  int result = 0;
+  if (!mysql_client_init) {
+    mysql_client_init = 1;
+    org_my_init_done = my_init_done;
+    if (my_init()) /* Will init threads */
+      return 1;
+    init_client_errs();
+    if (mysql_client_plugin_init()) return 1;
+#if defined(HAVE_OPENSSL)
+    ssl_start();
+#endif
+
+    if (!mysql_port) {
+      char *env;
+      struct servent *serv_ptr MY_ATTRIBUTE((unused));
+
+      mysql_port = MYSQL_PORT;
+
+      /*
+        if builder specifically requested a default port, use that
+        (even if it coincides with our factory default).
+        only if they didn't do we check /etc/services (and, failing
+        on that, fall back to the factory default of 3306).
+        either default can be overridden by the environment variable
+        MYSQL_TCP_PORT, which in turn can be overridden with command
+        line options.
+      */
+
+#if MYSQL_PORT_DEFAULT == 0
+      if ((serv_ptr = getservbyname("mysql", "tcp")))
+        mysql_port = (uint)ntohs((ushort)serv_ptr->s_port);
+#endif
+      if ((env = getenv("MYSQL_TCP_PORT"))) mysql_port = (uint)atoi(env);
+    }
+
+    if (!mysql_unix_port) {
+      char *env;
+#ifdef _WIN32
+      mysql_unix_port = const_cast<char *>(MYSQL_NAMEDPIPE);
+#else
+      mysql_unix_port = const_cast<char *>(MYSQL_UNIX_ADDR);
+#endif
+      if ((env = getenv("MYSQL_UNIX_PORT"))) mysql_unix_port = env;
+    }
+    mysql_debug(NullS);
+#if defined(SIGPIPE) && !defined(_WIN32)
+    (void)signal(SIGPIPE, SIG_IGN);
+#endif
+  } else
+    result = (int)my_thread_init(); /* Init if new thread */
+  return result;
+}
+
+/*
+  Free all memory and resources used by the client library
+
+  NOTES
+    When calling this there should not be any other threads using
+    the library.
+
+    To make things simpler when used with windows dll's (which calls this
+    function automaticly), it's safe to call this function multiple times.
+*/
+
+void STDCALL mysql_server_end() {
+  if (!mysql_client_init) return;
+
+  mysql_client_plugin_deinit();
+
+  finish_client_errs();
+  vio_end();
+
+  /* If library called my_init(), free memory allocated by it */
+  if (!org_my_init_done) {
+    my_end(0);
+  } else {
+    mysql_thread_end();
+  }
+
+  mysql_client_init = org_my_init_done = 0;
+}
+
+bool STDCALL mysql_thread_init() { return my_thread_init(); }
+
+void STDCALL mysql_thread_end() { my_thread_end(); }
+
+/*
+  Expand wildcard to a sql string
+*/
+
+static void append_wild(char *to, char *end, const char *wild) {
+  end -= 5; /* Some extra */
+  if (wild && wild[0]) {
+    to = my_stpcpy(to, " like '");
+    while (*wild && to < end) {
+      if (*wild == '\\' || *wild == '\'') *to++ = '\\';
+      *to++ = *wild++;
+    }
+    if (*wild)     /* Too small buffer */
+      *to++ = '%'; /* Nicer this way */
+    to[0] = '\'';
+    to[1] = 0;
+  }
+}
+
+/**************************************************************************
+  Init debugging if MYSQL_DEBUG environment variable is found
+**************************************************************************/
+
+void STDCALL mysql_debug(const char *debug MY_ATTRIBUTE((unused))) {
+#ifndef DBUG_OFF
+  char *env;
+  if (debug) {
+    DBUG_PUSH(debug);
+  } else if ((env = getenv("MYSQL_DEBUG"))) {
+    DBUG_PUSH(env);
+#if !defined(_WINVER) && !defined(WINVER)
+    puts("\n-------------------------------------------------------");
+    puts("MYSQL_DEBUG found. libmysql started with the following:");
+    puts(env);
+    puts("-------------------------------------------------------\n");
+#else
+    {
+      char buff[80];
+      buff[sizeof(buff) - 1] = 0;
+      strxnmov(buff, sizeof(buff) - 1, "libmysql: ", env, NullS);
+      MessageBox((HWND)0, "Debugging variable MYSQL_DEBUG used", buff, MB_OK);
+    }
+#endif
+  }
+#endif
+}
+
+/**************************************************************************
+  Change user and database
+**************************************************************************/
+
+bool STDCALL mysql_change_user(MYSQL *mysql, const char *user,
+                               const char *passwd, const char *db) {
+  int rc;
+  CHARSET_INFO *saved_cs = mysql->charset;
+  char *saved_user = mysql->user;
+  char *saved_passwd = mysql->passwd;
+  char *saved_db = mysql->db;
+
+  DBUG_ENTER("mysql_change_user");
+
+  /* Get the connection-default character set. */
+
+  if (mysql_init_character_set(mysql)) {
+    mysql->charset = saved_cs;
+    DBUG_RETURN(true);
+  }
+
+  /*
+    Use an empty string instead of NULL.
+    Alloc user and password on heap because mysql_reconnect()
+    calls mysql_close() on success.
+  */
+  mysql->user = my_strdup(PSI_NOT_INSTRUMENTED, user ? user : "", MYF(MY_WME));
+  mysql->passwd =
+      my_strdup(PSI_NOT_INSTRUMENTED, passwd ? passwd : "", MYF(MY_WME));
+  mysql->db = 0;
+
+  rc = run_plugin_auth(mysql, 0, 0, 0, db);
+
+  MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+
+  /*
+    The server will close all statements no matter was the attempt
+    to change user successful or not.
+  */
+  mysql_detach_stmt_list(&mysql->stmts, "mysql_change_user");
+  if (rc == 0) {
+    /* Free old connect information */
+    my_free(saved_user);
+    my_free(saved_passwd);
+    my_free(saved_db);
+
+    /* alloc new connect information */
+    mysql->db = db ? my_strdup(PSI_NOT_INSTRUMENTED, db, MYF(MY_WME)) : 0;
+  } else {
+    /* Free temporary connect information */
+    my_free(mysql->user);
+    my_free(mysql->passwd);
+    my_free(mysql->db);
+
+    /* Restore saved state */
+    mysql->charset = saved_cs;
+    mysql->user = saved_user;
+    mysql->passwd = saved_passwd;
+    mysql->db = saved_db;
+  }
+
+  DBUG_RETURN(rc);
+}
+
+#if defined(HAVE_GETPWUID) && defined(NO_GETPWUID_DECL)
+struct passwd *getpwuid(uid_t);
+char *getlogin(void);
+#endif
+
+#if !defined(_WIN32)
+
+void read_user_name(char *name) {
+  DBUG_ENTER("read_user_name");
+  if (geteuid() == 0)
+    (void)my_stpcpy(name, "root"); /* allow use of surun */
+  else {
+#ifdef HAVE_GETPWUID
+    struct passwd *skr;
+    const char *str;
+    if ((str = getlogin()) == NULL) {
+      if ((skr = getpwuid(geteuid())) != NULL)
+        str = skr->pw_name;
+      else if (!(str = getenv("USER")) && !(str = getenv("LOGNAME")) &&
+               !(str = getenv("LOGIN")))
+        str = "UNKNOWN_USER";
+    }
+    (void)strmake(name, str, USERNAME_LENGTH);
+#elif HAVE_CUSERID
+    (void)cuserid(name);
+#else
+    my_stpcpy(name, "UNKNOWN_USER");
+#endif
+  }
+  DBUG_VOID_RETURN;
+}
+
+#else /* If Windows */
+
+void read_user_name(char *name) {
+  char *str = getenv("USER"); /* ODBC will send user variable */
+  strmake(name, str ? str : "ODBC", USERNAME_LENGTH);
+}
+
+#endif
+
+bool handle_local_infile(MYSQL *mysql, const char *net_filename) {
+  bool result = 1;
+  uint packet_length = MY_ALIGN(mysql->net.max_packet - 16, IO_SIZE);
+  NET *net = &mysql->net;
+  int readcount;
+  void *li_ptr; /* pass state to local_infile functions */
+  char *buf;    /* buffer to be filled by local_infile_read */
+  struct st_mysql_options *options = &mysql->options;
+  DBUG_ENTER("handle_local_infile");
+
+  /* check that we've got valid callback functions */
+  if (!(options->local_infile_init && options->local_infile_read &&
+        options->local_infile_end && options->local_infile_error)) {
+    /* if any of the functions is invalid, set the default */
+    mysql_set_local_infile_default(mysql);
+  }
+
+  /* copy filename into local memory and allocate read buffer */
+  if (!(buf = pointer_cast<char *>(
+            my_malloc(PSI_NOT_INSTRUMENTED, packet_length, MYF(0))))) {
+    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
+    DBUG_RETURN(1);
+  }
+
+  /* initialize local infile (open file, usually) */
+  if ((*options->local_infile_init)(&li_ptr, net_filename,
+                                    options->local_infile_userdata)) {
+    MYSQL_TRACE(SEND_FILE, mysql, (0, NULL));
+    (void)my_net_write(net, (const uchar *)"", 0); /* Server needs one packet */
+    net_flush(net);
+    MYSQL_TRACE(PACKET_SENT, mysql, (0));
+    my_stpcpy(net->sqlstate, unknown_sqlstate);
+    net->last_errno = (*options->local_infile_error)(
+        li_ptr, net->last_error, sizeof(net->last_error) - 1);
+    MYSQL_TRACE(ERROR, mysql, ());
+    goto err;
+  }
+
+  /* read blocks of data from local infile callback */
+  while ((readcount =
+              (*options->local_infile_read)(li_ptr, buf, packet_length)) > 0) {
+    MYSQL_TRACE(SEND_FILE, mysql,
+                ((size_t)readcount, (const unsigned char *)buf));
+    if (my_net_write(net, (uchar *)buf, readcount)) {
+      DBUG_PRINT(
+          "error",
+          ("Lost connection to MySQL server during LOAD DATA of local file"));
+      set_mysql_error(mysql, CR_SERVER_LOST, unknown_sqlstate);
+      goto err;
+    }
+    MYSQL_TRACE(PACKET_SENT, mysql, (static_cast<size_t>(readcount)));
+  }
+
+  /* Send empty packet to mark end of file */
+  MYSQL_TRACE(SEND_FILE, mysql, (0, NULL));
+  if (my_net_write(net, (const uchar *)"", 0) || net_flush(net)) {
+    set_mysql_error(mysql, CR_SERVER_LOST, unknown_sqlstate);
+    goto err;
+  }
+  MYSQL_TRACE(PACKET_SENT, mysql, (0));
+
+  if (readcount < 0) {
+    net->last_errno = (*options->local_infile_error)(
+        li_ptr, net->last_error, sizeof(net->last_error) - 1);
+    MYSQL_TRACE(ERROR, mysql, ());
+    goto err;
+  }
+
+  result = 0; /* Ok */
+
+err:
+  /* free up memory allocated with _init, usually */
+  (*options->local_infile_end)(li_ptr);
+  my_free(buf);
+  DBUG_RETURN(result);
+}
+
+/****************************************************************************
+  Default handlers for LOAD LOCAL INFILE
+****************************************************************************/
+
+struct default_local_infile_data {
+  int fd;
+  int error_num;
+  const char *filename;
+  char error_msg[LOCAL_INFILE_ERROR_LEN];
+};
+
+/*
+  Open file for LOAD LOCAL INFILE
+
+  SYNOPSIS
+    default_local_infile_init()
+    ptr			Store pointer to internal data here
+    filename		File name to open. This may be in unix format !
+
+
+  NOTES
+    Even if this function returns an error, the load data interface
+    guarantees that default_local_infile_end() is called.
+
+  RETURN
+    0	ok
+    1	error
+*/
+
+static int default_local_infile_init(void **ptr, const char *filename,
+                                     void *userdata MY_ATTRIBUTE((unused))) {
+  default_local_infile_data *data;
+  char tmp_name[FN_REFLEN];
+
+  if (!(*ptr = data = ((default_local_infile_data *)my_malloc(
+            PSI_NOT_INSTRUMENTED, sizeof(default_local_infile_data), MYF(0)))))
+    return 1; /* out of memory */
+
+  data->error_msg[0] = 0;
+  data->error_num = 0;
+  data->filename = filename;
+
+  fn_format(tmp_name, filename, "", "", MY_UNPACK_FILENAME);
+  if ((data->fd = my_open(tmp_name, O_RDONLY, MYF(0))) < 0) {
+    char errbuf[MYSYS_STRERROR_SIZE];
+    data->error_num = my_errno();
+    snprintf(data->error_msg, sizeof(data->error_msg) - 1, EE(EE_FILENOTFOUND),
+             tmp_name, data->error_num,
+             my_strerror(errbuf, sizeof(errbuf), data->error_num));
+    return 1;
+  }
+  return 0; /* ok */
+}
+
+/*
+  Read data for LOAD LOCAL INFILE
+
+  SYNOPSIS
+    default_local_infile_read()
+    ptr			Points to handle allocated by _init
+    buf			Read data here
+    buf_len		Ammount of data to read
+
+  RETURN
+    > 0		number of bytes read
+    == 0	End of data
+    < 0		Error
+*/
+
+static int default_local_infile_read(void *ptr, char *buf, uint buf_len) {
+  int count;
+  default_local_infile_data *data = (default_local_infile_data *)ptr;
+
+  if ((count = (int)my_read(data->fd, (uchar *)buf, buf_len, MYF(0))) < 0) {
+    char errbuf[MYSYS_STRERROR_SIZE];
+    data->error_num = EE_READ; /* the errmsg for not entire file read */
+    snprintf(data->error_msg, sizeof(data->error_msg) - 1, EE(EE_READ),
+             data->filename, my_errno(),
+             my_strerror(errbuf, sizeof(errbuf), my_errno()));
+  }
+  return count;
+}
+
+/*
+  Read data for LOAD LOCAL INFILE
+
+  SYNOPSIS
+    default_local_infile_end()
+    ptr			Points to handle allocated by _init
+                        May be NULL if _init failed!
+
+  RETURN
+*/
+
+static void default_local_infile_end(void *ptr) {
+  default_local_infile_data *data = (default_local_infile_data *)ptr;
+  if (data) /* If not error on open */
+  {
+    if (data->fd >= 0) my_close(data->fd, MYF(MY_WME));
+    my_free(ptr);
+  }
+}
+
+/*
+  Return error from LOAD LOCAL INFILE
+
+  SYNOPSIS
+    default_local_infile_end()
+    ptr			Points to handle allocated by _init
+                        May be NULL if _init failed!
+    error_msg		Store error text here
+    error_msg_len	Max lenght of error_msg
+
+  RETURN
+    error message number
+*/
+
+static int default_local_infile_error(void *ptr, char *error_msg,
+                                      uint error_msg_len) {
+  default_local_infile_data *data = (default_local_infile_data *)ptr;
+  if (data) /* If not error on open */
+  {
+    strmake(error_msg, data->error_msg, error_msg_len);
+    return data->error_num;
+  }
+  /* This can only happen if we got error on malloc of handle */
+  my_stpcpy(error_msg, ER_CLIENT(CR_OUT_OF_MEMORY));
+  return CR_OUT_OF_MEMORY;
+}
+
+/*
+  Explicit extern "C" because otherwise solaris studio thinks
+  that the function pointer arguments have C++ linkage,
+  and then it overloads the declaration in include/mysql.h
+ */
+extern "C" void mysql_set_local_infile_handler(
+    MYSQL *mysql, int (*local_infile_init)(void **, const char *, void *),
+    int (*local_infile_read)(void *, char *, uint),
+    void (*local_infile_end)(void *),
+    int (*local_infile_error)(void *, char *, uint), void *userdata) {
+  mysql->options.local_infile_init = local_infile_init;
+  mysql->options.local_infile_read = local_infile_read;
+  mysql->options.local_infile_end = local_infile_end;
+  mysql->options.local_infile_error = local_infile_error;
+  mysql->options.local_infile_userdata = userdata;
+}
+
+void mysql_set_local_infile_default(MYSQL *mysql) {
+  mysql->options.local_infile_init = default_local_infile_init;
+  mysql->options.local_infile_read = default_local_infile_read;
+  mysql->options.local_infile_end = default_local_infile_end;
+  mysql->options.local_infile_error = default_local_infile_error;
+}
+
+/**************************************************************************
+  Do a query. If query returned rows, free old rows.
+  Read data by mysql_store_result or by repeat call of mysql_fetch_row
+**************************************************************************/
+
+int STDCALL mysql_query(MYSQL *mysql, const char *query) {
+  return mysql_real_query(mysql, query, (ulong)strlen(query));
+}
+
+/**************************************************************************
+  Return next field of the query results
+**************************************************************************/
+
+MYSQL_FIELD *STDCALL mysql_fetch_field(MYSQL_RES *result) {
+  if (result->current_field >= result->field_count || !result->fields)
+    return (NULL);
+  return &result->fields[result->current_field++];
+}
+
+/**************************************************************************
+  Move to a specific row and column
+**************************************************************************/
+
+void STDCALL mysql_data_seek(MYSQL_RES *result, my_ulonglong row) {
+  MYSQL_ROWS *tmp = 0;
+  DBUG_PRINT("info", ("mysql_data_seek(%ld)", (long)row));
+  if (result->data)
+    for (tmp = result->data->data; row-- && tmp; tmp = tmp->next)
+      ;
+  result->current_row = 0;
+  result->data_cursor = tmp;
+}
+
+/*************************************************************************
+  put the row or field cursor one a position one got from mysql_row_tell()
+  This doesn't restore any data. The next mysql_fetch_row or
+  mysql_fetch_field will return the next row or field after the last used
+*************************************************************************/
+
+MYSQL_ROW_OFFSET STDCALL mysql_row_seek(MYSQL_RES *result,
+                                        MYSQL_ROW_OFFSET row) {
+  MYSQL_ROW_OFFSET return_value = result->data_cursor;
+  result->current_row = 0;
+  result->data_cursor = row;
+  return return_value;
+}
+
+MYSQL_FIELD_OFFSET STDCALL mysql_field_seek(MYSQL_RES *result,
+                                            MYSQL_FIELD_OFFSET field_offset) {
+  MYSQL_FIELD_OFFSET return_value = result->current_field;
+  result->current_field = field_offset;
+  return return_value;
+}
+
+/*****************************************************************************
+  List all databases
+*****************************************************************************/
+
+MYSQL_RES *STDCALL mysql_list_dbs(MYSQL *mysql, const char *wild) {
+  char buff[255];
+  DBUG_ENTER("mysql_list_dbs");
+
+  append_wild(my_stpcpy(buff, "show databases"), buff + sizeof(buff), wild);
+  if (mysql_query(mysql, buff)) DBUG_RETURN(0);
+  DBUG_RETURN(mysql_store_result(mysql));
+}
+
+/*****************************************************************************
+  List all tables in a database
+  If wild is given then only the tables matching wild is returned
+*****************************************************************************/
+
+MYSQL_RES *STDCALL mysql_list_tables(MYSQL *mysql, const char *wild) {
+  char buff[255];
+  DBUG_ENTER("mysql_list_tables");
+
+  append_wild(my_stpcpy(buff, "show tables"), buff + sizeof(buff), wild);
+  if (mysql_query(mysql, buff)) DBUG_RETURN(0);
+  DBUG_RETURN(mysql_store_result(mysql));
+}
+
+MYSQL_FIELD *cli_list_fields(MYSQL *mysql) {
+  MYSQL_DATA *query;
+  MYSQL_FIELD *result;
+
+  MYSQL_TRACE_STAGE(mysql, WAIT_FOR_FIELD_DEF);
+  query = cli_read_rows(mysql, (MYSQL_FIELD *)0, protocol_41(mysql) ? 8 : 6);
+  MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+
+  if (!query) return NULL;
+
+  mysql->field_count = (uint)query->rows;
+  result = unpack_fields(mysql, query->data, mysql->field_alloc,
+                         mysql->field_count, 1, mysql->server_capabilities);
+  free_rows(query);
+  return result;
+}
+
+/**************************************************************************
+  List all fields in a table
+  If wild is given then only the fields matching wild is returned
+  Instead of this use query:
+  show fields in 'table' like "wild"
+**************************************************************************/
+
+MYSQL_RES *STDCALL mysql_list_fields(MYSQL *mysql, const char *table,
+                                     const char *wild) {
+  MYSQL_RES *result;
+  MYSQL_FIELD *fields;
+  MEM_ROOT *new_root;
+  char buff[258], *end;
+  DBUG_ENTER("mysql_list_fields");
+  DBUG_PRINT("enter", ("table: '%s'  wild: '%s'", table, wild ? wild : ""));
+
+  end = strmake(strmake(buff, table, 128) + 1, wild ? wild : "", 128);
+  free_old_query(mysql);
+  if (simple_command(mysql, COM_FIELD_LIST, (uchar *)buff, (ulong)(end - buff),
+                     1) ||
+      !(fields = (*mysql->methods->list_fields)(mysql)))
+    DBUG_RETURN(NULL);
+
+  if (!(new_root = (MEM_ROOT *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MEM_ROOT),
+                                         MYF(MY_WME | MY_ZEROFILL))))
+    DBUG_RETURN(NULL);
+  if (!(result = (MYSQL_RES *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MYSQL_RES),
+                                        MYF(MY_WME | MY_ZEROFILL)))) {
+    my_free(new_root);
+    DBUG_RETURN(NULL);
+  }
+
+  result->methods = mysql->methods;
+  result->field_alloc = mysql->field_alloc;
+  mysql->fields = 0;
+  mysql->field_alloc = new_root;
+  result->field_count = mysql->field_count;
+  result->fields = fields;
+  result->eof = 1;
+  DBUG_RETURN(result);
+}
+
+/* List all running processes (threads) in server */
+
+MYSQL_RES *STDCALL mysql_list_processes(MYSQL *mysql) {
+  uint field_count;
+  uchar *pos;
+  DBUG_ENTER("mysql_list_processes");
+
+  if (simple_command(mysql, COM_PROCESS_INFO, 0, 0, 0)) DBUG_RETURN(0);
+  free_old_query(mysql);
+  pos = (uchar *)mysql->net.read_pos;
+  field_count = (uint)net_field_length(&pos);
+  if (!(mysql->fields =
+            cli_read_metadata(mysql, field_count, protocol_41(mysql) ? 7 : 5)))
+    DBUG_RETURN(NULL);
+  mysql->status = MYSQL_STATUS_GET_RESULT;
+  mysql->field_count = field_count;
+  DBUG_RETURN(mysql_store_result(mysql));
+}
+
+int STDCALL mysql_shutdown(MYSQL *mysql,
+                           enum mysql_enum_shutdown_level shutdown_level
+                               MY_ATTRIBUTE((unused))) {
+  if (mysql_get_server_version(mysql) < 50709)
+    return simple_command(mysql, COM_DEPRECATED_1, 0, 0, 0);
+  else
+    return mysql_real_query(mysql, STRING_WITH_LEN("shutdown"));
+}
+
+int STDCALL mysql_refresh(MYSQL *mysql, uint options) {
+  uchar bits[1];
+  DBUG_ENTER("mysql_refresh");
+  bits[0] = (uchar)options;
+  DBUG_RETURN(simple_command(mysql, COM_REFRESH, bits, 1, 0));
+}
+
+int STDCALL mysql_kill(MYSQL *mysql, ulong pid) {
+  uchar buff[4];
+  DBUG_ENTER("mysql_kill");
+  /*
+    Sanity check: if ulong is 64-bits, user can submit a PID here that
+    overflows our 32-bit parameter to the somewhat obsolete COM_PROCESS_KILL.
+    If this is the case, we'll flag an error here.
+    The SQL statement KILL CONNECTION is the safer option here.
+    There is an analog of this failsafe in the server as we might see old
+    libmysql connection to a new server as well as the other way around.
+  */
+  if (pid & (~0xfffffffful)) DBUG_RETURN(CR_INVALID_CONN_HANDLE);
+  int4store(buff, pid);
+  DBUG_RETURN(simple_command(mysql, COM_PROCESS_KILL, buff, sizeof(buff), 0));
+}
+
+int STDCALL mysql_set_server_option(MYSQL *mysql,
+                                    enum enum_mysql_set_option option) {
+  uchar buff[2];
+  DBUG_ENTER("mysql_set_server_option");
+  int2store(buff, (uint)option);
+  DBUG_RETURN(simple_command(mysql, COM_SET_OPTION, buff, sizeof(buff), 0));
+}
+
+int STDCALL mysql_dump_debug_info(MYSQL *mysql) {
+  DBUG_ENTER("mysql_dump_debug_info");
+  DBUG_RETURN(simple_command(mysql, COM_DEBUG, 0, 0, 0));
+}
+
+const char *cli_read_statistics(MYSQL *mysql) {
+  mysql->net.read_pos[mysql->packet_length] = 0; /* End of stat string */
+  if (!mysql->net.read_pos[0]) {
+    set_mysql_error(mysql, CR_WRONG_HOST_INFO, unknown_sqlstate);
+    return mysql->net.last_error;
+  }
+  /*
+    After reading the single packet with reply to COM_STATISTICS
+    we are ready for new commands.
+  */
+  MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+  return (char *)mysql->net.read_pos;
+}
+
+const char *STDCALL mysql_stat(MYSQL *mysql) {
+  DBUG_ENTER("mysql_stat");
+  if (simple_command(mysql, COM_STATISTICS, 0, 0, 0))
+    DBUG_RETURN(mysql->net.last_error);
+  DBUG_RETURN((*mysql->methods->read_statistics)(mysql));
+}
+
+int STDCALL mysql_ping(MYSQL *mysql) {
+  int res;
+  DBUG_ENTER("mysql_ping");
+  res = simple_command(mysql, COM_PING, 0, 0, 0);
+  if (res == CR_SERVER_LOST && mysql->reconnect)
+    res = simple_command(mysql, COM_PING, 0, 0, 0);
+  DBUG_RETURN(res);
+}
+
+const char *STDCALL mysql_get_server_info(MYSQL *mysql) {
+  return ((char *)mysql->server_version);
+}
+
+const char *STDCALL mysql_get_host_info(MYSQL *mysql) {
+  return (mysql->host_info);
+}
+
+uint STDCALL mysql_get_proto_info(MYSQL *mysql) {
+  return (mysql->protocol_version);
+}
+
+const char *STDCALL mysql_get_client_info(void) { return MYSQL_SERVER_VERSION; }
+
+ulong STDCALL mysql_get_client_version(void) { return MYSQL_VERSION_ID; }
+
+bool STDCALL mysql_eof(MYSQL_RES *res) { return res->eof; }
+
+MYSQL_FIELD *STDCALL mysql_fetch_field_direct(MYSQL_RES *res, uint fieldnr) {
+  if (fieldnr >= res->field_count || !res->fields) return (NULL);
+  return &(res)->fields[fieldnr];
+}
+
+MYSQL_FIELD *STDCALL mysql_fetch_fields(MYSQL_RES *res) {
+  return (res)->fields;
+}
+
+MYSQL_ROW_OFFSET STDCALL mysql_row_tell(MYSQL_RES *res) {
+  return res->data_cursor;
+}
+
+MYSQL_FIELD_OFFSET STDCALL mysql_field_tell(MYSQL_RES *res) {
+  return (res)->current_field;
+}
+
+enum_resultset_metadata STDCALL mysql_result_metadata(MYSQL_RES *result) {
+  return result->metadata;
+}
+
+/* MYSQL */
+
+unsigned int STDCALL mysql_field_count(MYSQL *mysql) {
+  return mysql->field_count;
+}
+
+my_ulonglong STDCALL mysql_affected_rows(MYSQL *mysql) {
+  return mysql->affected_rows;
+}
+
+my_ulonglong STDCALL mysql_insert_id(MYSQL *mysql) { return mysql->insert_id; }
+
+const char *STDCALL mysql_sqlstate(MYSQL *mysql) {
+  return mysql ? mysql->net.sqlstate : cant_connect_sqlstate;
+}
+
+uint STDCALL mysql_warning_count(MYSQL *mysql) { return mysql->warning_count; }
+
+const char *STDCALL mysql_info(MYSQL *mysql) {
+  if (!mysql) {
+#if defined(CLIENT_PROTOCOL_TRACING)
+    return "protocol tracing enabled";
+#else
+    return NULL;
+#endif
+  }
+  return mysql->info;
+}
+
+ulong STDCALL mysql_thread_id(MYSQL *mysql) {
+  /*
+    ulong may be 64-bit, but we currently only transmit 32-bit.
+    mysql_thread_id() is usually used in conjunction with mysql_kill()
+    which is similarly limited (and obsolete).
+    SELECTION CONNECTION_ID() / KILL CONNECTION avoid this issue.
+  */
+  return (mysql)->thread_id;
+}
+
+const char *STDCALL mysql_character_set_name(MYSQL *mysql) {
+  return mysql->charset->csname;
+}
+
+void STDCALL mysql_get_character_set_info(MYSQL *mysql,
+                                          MY_CHARSET_INFO *csinfo) {
+  csinfo->number = mysql->charset->number;
+  csinfo->state = mysql->charset->state;
+  csinfo->csname = mysql->charset->csname;
+  csinfo->name = mysql->charset->name;
+  csinfo->comment = mysql->charset->comment;
+  csinfo->mbminlen = mysql->charset->mbminlen;
+  csinfo->mbmaxlen = mysql->charset->mbmaxlen;
+
+  if (mysql->options.charset_dir)
+    csinfo->dir = mysql->options.charset_dir;
+  else
+    csinfo->dir = charsets_dir;
+}
+
+uint STDCALL mysql_thread_safe(void) { return 1; }
+
+/****************************************************************************
+  Some support functions
+****************************************************************************/
+
+/*
+  Functions called my my_net_init() to set some application specific variables
+*/
+
+void my_net_local_init(NET *net) {
+  ulong local_net_buffer_length = 0;
+  ulong local_max_allowed_packet = 0;
+
+  (void)mysql_get_option(NULL, MYSQL_OPT_MAX_ALLOWED_PACKET,
+                         &local_max_allowed_packet);
+  (void)mysql_get_option(NULL, MYSQL_OPT_NET_BUFFER_LENGTH,
+                         &local_net_buffer_length);
+
+  net->max_packet = (uint)local_net_buffer_length;
+  my_net_set_read_timeout(net, CLIENT_NET_READ_TIMEOUT);
+  my_net_set_write_timeout(net, CLIENT_NET_WRITE_TIMEOUT);
+  my_net_set_retry_count(net, CLIENT_NET_RETRY_COUNT);
+  net->max_packet_size =
+      MY_MAX(local_net_buffer_length, local_max_allowed_packet);
+}
+
+/*
+  This function is used to create HEX string that you
+  can use in a SQL statement in of the either ways:
+    INSERT INTO blob_column VALUES (0xAABBCC);  (any MySQL version)
+    INSERT INTO blob_column VALUES (X'AABBCC'); (4.1 and higher)
+
+  The string in "from" is encoded to a HEX string.
+  The result is placed in "to" and a terminating null byte is appended.
+
+  The string pointed to by "from" must be "length" bytes long.
+  You must allocate the "to" buffer to be at least length*2+1 bytes long.
+  Each character needs two bytes, and you need room for the terminating
+  null byte. When mysql_hex_string() returns, the contents of "to" will
+  be a null-terminated string. The return value is the length of the
+  encoded string, not including the terminating null character.
+
+  The return value does not contain any leading 0x or a leading X' and
+  trailing '. The caller must supply whichever of those is desired.
+*/
+
+ulong STDCALL mysql_hex_string(char *to, const char *from, ulong length) {
+  char *to0 = to;
+  const char *end;
+
+  for (end = from + length; from < end; from++) {
+    *to++ = _dig_vec_upper[((unsigned char)*from) >> 4];
+    *to++ = _dig_vec_upper[((unsigned char)*from) & 0x0F];
+  }
+  *to = '\0';
+  return (ulong)(to - to0);
+}
+
+/*
+  Add escape characters to a string (blob?) to make it suitable for a insert
+  to should at least have place for length*2+1 chars
+  Returns the length of the to string
+*/
+
+ulong STDCALL mysql_escape_string(char *to, const char *from, ulong length) {
+  return (uint)escape_string_for_mysql(default_charset_info, to, 0, from,
+                                       length);
+}
+
+/**
+  Escapes special characters in a string for use in an SQL statement.
+
+  Escapes special characters in the unescaped string, taking into account
+  the current character set and sql mode of the connection so that is safe
+  to place the string in a mysql_query(). This function must be used for
+  binary data.
+
+  This function does not work correctly when NO_BACKSLASH_ESCAPES sql mode
+  is used and string quote in the SQL statement is different than '\''.
+
+  @deprecated This function should not be used.
+              Use mysql_real_escape_string_quote instead.
+
+  @see mysql_real_escape_string_quote
+
+  @param [in] mysql   MySQL connection structure.
+  @param [out] to     Escaped string output buffer.
+  @param [in] from    String to escape.
+  @param [in] length  String to escape length.
+
+  @return Result value.
+    @retval != (ulong)-1 Succeeded. Number of bytes written to the output
+                         buffer without the '\0' character.
+    @retval (ulong)-1    Failed. Use mysql_error() to get error message.
+*/
+
+ulong STDCALL mysql_real_escape_string(MYSQL *mysql, char *to, const char *from,
+                                       ulong length) {
+  if (mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES) {
+    DBUG_PRINT("error", ("NO_BACKSLASH_ESCAPES sql mode requires usage of the "
+                         "mysql_real_escape_string_quote function"));
+    set_mysql_extended_error(mysql, CR_INSECURE_API_ERR, unknown_sqlstate,
+                             ER_CLIENT(CR_INSECURE_API_ERR),
+                             "mysql_real_escape_string",
+                             "mysql_real_escape_string_quote");
+    return (ulong)-1;
+  }
+
+  return (uint)mysql_real_escape_string_quote(mysql, to, from, length, '\'');
+}
+
+/**
+  Escapes special characters in a string for use in an SQL statement.
+
+  Escapes special characters in the unescaped string, taking into account
+  the current character set and sql mode of the connection so that is safe
+  to place the string in a mysql_query(). This function must be used for
+  binary data.
+
+  This function should be used for escaping identifiers and string parameters.
+
+  @param [in] mysql   MySQL connection structure.
+  @param [out] to     Escaped string output buffer.
+  @param [in] from    String to escape.
+  @param [in] length  String to escape length.
+  @param [in] quote   String quoting character used in an SQL statement. This
+                      should be one of '\'', '"' or '`' depending on the
+                      parameter quoting applied in the SQL statement.
+
+  @return Result value.
+    @retval != (ulong)-1 Succeeded. Number of bytes written to the output
+                         buffer without the '\0' character.
+    @retval (ulong)-1    Failed.
+*/
+
+ulong STDCALL mysql_real_escape_string_quote(MYSQL *mysql, char *to,
+                                             const char *from, ulong length,
+                                             char quote) {
+  if (quote == '`' || mysql->server_status & SERVER_STATUS_NO_BACKSLASH_ESCAPES)
+    return (uint)escape_quotes_for_mysql(mysql->charset, to, 0, from, length,
+                                         quote);
+  return (uint)escape_string_for_mysql(mysql->charset, to, 0, from, length);
+}
+
+void STDCALL myodbc_remove_escape(MYSQL *mysql, char *name) {
+  char *to;
+  bool use_mb_flag = use_mb(mysql->charset);
+  char *end = NULL;
+  if (use_mb_flag)
+    for (end = name; *end; end++)
+      ;
+
+  for (to = name; *name; name++) {
+    int l;
+    if (use_mb_flag && (l = my_ismbchar(mysql->charset, name, end))) {
+      while (l--) *to++ = *name++;
+      name--;
+      continue;
+    }
+    if (*name == '\\' && name[1]) name++;
+    *to++ = *name;
+  }
+  *to = 0;
+}
+
+/********************************************************************
+ Implementation of new client API for 4.1 version.
+
+ mysql_stmt_* are real prototypes used by applications.
+
+ All functions performing
+ real I/O are prefixed with 'cli_' (abbreviated from 'Call Level
+ Interface'). This functions are invoked via pointers set in
+ MYSQL::methods structure.
+*********************************************************************/
+
+/******************* Declarations ***********************************/
+
+/* Default number of rows fetched per one COM_STMT_FETCH command. */
+
+#define DEFAULT_PREFETCH_ROWS (ulong)1
+
+/*
+  These functions are called by function pointer MYSQL_STMT::read_row_func.
+  Each function corresponds to one of the read methods:
+  - mysql_stmt_fetch without prior mysql_stmt_store_result,
+  - mysql_stmt_fetch when result is stored,
+  - mysql_stmt_fetch when there are no rows (always returns MYSQL_NO_DATA)
+*/
+
+static int stmt_read_row_unbuffered(MYSQL_STMT *stmt, unsigned char **row);
+static int stmt_read_row_buffered(MYSQL_STMT *stmt, unsigned char **row);
+static int stmt_read_row_from_cursor(MYSQL_STMT *stmt, unsigned char **row);
+static int stmt_read_row_no_data(MYSQL_STMT *stmt, unsigned char **row);
+static int stmt_read_row_no_result_set(MYSQL_STMT *stmt, unsigned char **row);
+
+/*
+  This function is used in mysql_stmt_store_result if
+  STMT_ATTR_UPDATE_MAX_LENGTH attribute is set.
+*/
+static void stmt_update_metadata(MYSQL_STMT *stmt, MYSQL_ROWS *data);
+static bool setup_one_fetch_function(MYSQL_BIND *, MYSQL_FIELD *field);
+
+/* Auxilary function used to reset statement handle. */
+
+#define RESET_SERVER_SIDE 1
+#define RESET_LONG_DATA 2
+#define RESET_STORE_RESULT 4
+#define RESET_CLEAR_ERROR 8
+
+static bool reset_stmt_handle(MYSQL_STMT *stmt, uint flags);
+
+/*
+  Maximum sizes of MYSQL_TYPE_DATE, MYSQL_TYPE_TIME, MYSQL_TYPE_DATETIME
+  values stored in network buffer.
+*/
+
+/* 1 (length) + 2 (year) + 1 (month) + 1 (day) */
+#define MAX_DATE_REP_LENGTH 5
+
+/*
+  1 (length) + 1 (is negative) + 4 (day count) + 1 (hour)
+  + 1 (minute) + 1 (seconds) + 4 (microseconds)
+*/
+#define MAX_TIME_REP_LENGTH 13
+
+/*
+  1 (length) + 2 (year) + 1 (month) + 1 (day) +
+  1 (hour) + 1 (minute) + 1 (second) + 4 (microseconds)
+*/
+#define MAX_DATETIME_REP_LENGTH 12
+
+#define MAX_DOUBLE_STRING_REP_LENGTH 331
+
+/* A macro to check truncation errors */
+
+#define IS_TRUNCATED(value, is_unsigned, min, max, umax)       \
+  ((is_unsigned) ? (((value) > (umax) || (value) < 0) ? 1 : 0) \
+                 : (((value) > (max) || (value) < (min)) ? 1 : 0))
+
+#define BIND_RESULT_DONE 1
+/*
+  We report truncations only if at least one of MYSQL_BIND::error
+  pointers is set. In this case stmt->bind_result_done |-ed with
+  this flag.
+*/
+#define REPORT_DATA_TRUNCATION 2
+
+/**************** Misc utility functions ****************************/
+
+/*
+  Reallocate the NET package to have at least length bytes available.
+
+  SYNPOSIS
+    my_realloc_str()
+    net                 The NET structure to modify.
+    length              Ensure that net->buff has space for at least
+                        this number of bytes.
+
+  RETURN VALUES
+    0   Success.
+    1   Error, i.e. out of memory or requested packet size is bigger
+        than max_allowed_packet. The error code is stored in net->last_errno.
+*/
+
+static bool my_realloc_str(NET *net, ulong length) {
+  ulong buf_length = (ulong)(net->write_pos - net->buff);
+  bool res = 0;
+  DBUG_ENTER("my_realloc_str");
+  if (buf_length + length > net->max_packet) {
+    res = net_realloc(net, buf_length + length);
+    if (res) {
+      if (net->last_errno == ER_OUT_OF_RESOURCES)
+        net->last_errno = CR_OUT_OF_MEMORY;
+      else if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
+        net->last_errno = CR_NET_PACKET_TOO_LARGE;
+
+      my_stpcpy(net->sqlstate, unknown_sqlstate);
+      my_stpcpy(net->last_error, ER_CLIENT(net->last_errno));
+    }
+    net->write_pos = net->buff + buf_length;
+  }
+  DBUG_RETURN(res);
+}
+
+static void stmt_clear_error(MYSQL_STMT *stmt) {
+  if (stmt->last_errno) {
+    stmt->last_errno = 0;
+    stmt->last_error[0] = '\0';
+    my_stpcpy(stmt->sqlstate, not_error_sqlstate);
+  }
+}
+
+/**
+  Set statement error code, sqlstate, and error message
+  from given errcode and sqlstate.
+*/
+
+void set_stmt_error(MYSQL_STMT *stmt, int errcode, const char *sqlstate,
+                    const char *err) {
+  DBUG_ENTER("set_stmt_error");
+  DBUG_PRINT("enter", ("error: %d '%s'", errcode, ER_CLIENT(errcode)));
+  DBUG_ASSERT(stmt != 0);
+
+  if (err == 0) err = ER_CLIENT(errcode);
+
+  stmt->last_errno = errcode;
+  my_stpcpy(stmt->last_error, ER_CLIENT(errcode));
+  my_stpcpy(stmt->sqlstate, sqlstate);
+
+  DBUG_VOID_RETURN;
+}
+
+/**
+  Set statement error code, sqlstate, and error message from NET.
+
+  @param stmt  a statement handle. Copy the error here.
+  @param net   mysql->net. Source of the error.
+*/
+
+void set_stmt_errmsg(MYSQL_STMT *stmt, NET *net) {
+  DBUG_ENTER("set_stmt_errmsg");
+  DBUG_PRINT("enter", ("error: %d/%s '%s'", net->last_errno, net->sqlstate,
+                       net->last_error));
+  DBUG_ASSERT(stmt != 0);
+
+  stmt->last_errno = net->last_errno;
+  if (net->last_error[0] != '\0') my_stpcpy(stmt->last_error, net->last_error);
+  my_stpcpy(stmt->sqlstate, net->sqlstate);
+
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Read and unpack server reply to COM_STMT_PREPARE command (sent from
+  mysql_stmt_prepare).
+
+  SYNOPSIS
+    cli_read_prepare_result()
+    mysql   connection handle
+    stmt    statement handle
+
+  RETURN VALUES
+    0	ok
+    1	error
+*/
+
+bool cli_read_prepare_result(MYSQL *mysql, MYSQL_STMT *stmt) {
+  uchar *pos;
+  uint field_count, param_count;
+  ulong packet_length;
+  DBUG_ENTER("cli_read_prepare_result");
+
+  /* free old result and initialize mysql->field_alloc */
+  free_old_query(mysql);
+
+  if ((packet_length = cli_safe_read(mysql, NULL)) == packet_error)
+    DBUG_RETURN(1);
+  mysql->warning_count = 0;
+
+  pos = (uchar *)mysql->net.read_pos;
+  stmt->stmt_id = uint4korr(pos + 1);
+  pos += 5;
+  /* Number of columns in result set */
+  field_count = uint2korr(pos);
+  pos += 2;
+  /* Number of placeholders in the statement */
+  param_count = uint2korr(pos);
+  pos += 2;
+
+  mysql->resultset_metadata = RESULTSET_METADATA_FULL;
+  if (packet_length >= 12) {
+    mysql->warning_count = uint2korr(pos + 1);
+    if (mysql->client_flag & CLIENT_OPTIONAL_RESULTSET_METADATA) {
+      mysql->resultset_metadata =
+          static_cast<enum enum_resultset_metadata>(*(pos + 3));
+    }
+  }
+
+  if (param_count != 0 &&
+      mysql->resultset_metadata == RESULTSET_METADATA_FULL) {
+    MYSQL_TRACE_STAGE(mysql, WAIT_FOR_PARAM_DEF);
+    /* skip parameters data: we don't support it yet */
+    if (!(cli_read_metadata(mysql, param_count, 7))) DBUG_RETURN(1);
+    /* free memory allocated by cli_read_metadata() for parameters data */
+    free_root(mysql->field_alloc, MYF(0));
+  }
+
+  if (field_count != 0) {
+    if (!(mysql->server_status & SERVER_STATUS_AUTOCOMMIT))
+      mysql->server_status |= SERVER_STATUS_IN_TRANS;
+
+    if (mysql->resultset_metadata == RESULTSET_METADATA_FULL) {
+      MYSQL_TRACE_STAGE(mysql, WAIT_FOR_FIELD_DEF);
+      if (!(stmt->fields =
+                cli_read_metadata_ex(mysql, stmt->mem_root, field_count, 7)))
+        DBUG_RETURN(1);
+    }
+  }
+
+  MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+
+  stmt->field_count = field_count;
+  stmt->param_count = (ulong)param_count;
+  DBUG_PRINT("exit", ("field_count: %u  param_count: %u  warning_count: %u",
+                      field_count, param_count, (uint)mysql->warning_count));
+
+  DBUG_RETURN(0);
+}
+
+/*
+  Allocate memory and init prepared statement structure.
+
+  SYNOPSIS
+    mysql_stmt_init()
+    mysql   connection handle
+
+  DESCRIPTION
+    This is an entry point of the new API. Returned handle stands for
+    a server-side prepared statement. Memory for this structure (~700
+    bytes) is allocated using 'malloc'. Once created, the handle can be
+    reused many times. Created statement handle is bound to connection
+    handle provided to this call: its lifetime is limited by lifetime
+    of connection.
+    'mysql_stmt_init()' is a pure local call, server side structure is
+    created only in mysql_stmt_prepare.
+    Next steps you may want to make:
+    - set a statement attribute (mysql_stmt_attr_set()),
+    - prepare statement handle with a query (mysql_stmt_prepare()),
+    - close statement handle and free its memory (mysql_stmt_close()),
+    - reset statement with mysql_stmt_reset() (a no-op which will
+      just return).
+    Behaviour of the rest of API calls on this statement is not defined yet
+    (though we're working on making each wrong call sequence return
+    error).
+
+  RETURN VALUE
+    statement structure upon success and NULL if out of
+    memory
+*/
+
+MYSQL_STMT *STDCALL mysql_stmt_init(MYSQL *mysql) {
+  MYSQL_STMT *stmt;
+  DBUG_ENTER("mysql_stmt_init");
+
+  if (!(stmt = (MYSQL_STMT *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MYSQL_STMT),
+                                       MYF(MY_WME | MY_ZEROFILL))) ||
+      !(stmt->extension = (MYSQL_STMT_EXT *)my_malloc(
+            PSI_NOT_INSTRUMENTED, sizeof(MYSQL_STMT_EXT),
+            MYF(MY_WME | MY_ZEROFILL))) ||
+      !(stmt->mem_root =
+            (MEM_ROOT *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MEM_ROOT),
+                                  MYF(MY_WME | MY_ZEROFILL))) ||
+      !(stmt->result.alloc =
+            (MEM_ROOT *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(MEM_ROOT),
+                                  MYF(MY_WME | MY_ZEROFILL)))) {
+    set_mysql_error(mysql, CR_OUT_OF_MEMORY, unknown_sqlstate);
+    my_free(stmt);
+    DBUG_RETURN(NULL);
+  }
+
+  init_alloc_root(PSI_NOT_INSTRUMENTED, stmt->mem_root, 2048, 2048);
+  init_alloc_root(PSI_NOT_INSTRUMENTED, stmt->result.alloc, 4096, 4096);
+  mysql->stmts = list_add(mysql->stmts, &stmt->list);
+  stmt->list.data = stmt;
+  stmt->state = MYSQL_STMT_INIT_DONE;
+  stmt->mysql = mysql;
+  stmt->read_row_func = stmt_read_row_no_result_set;
+  stmt->prefetch_rows = DEFAULT_PREFETCH_ROWS;
+  my_stpcpy(stmt->sqlstate, not_error_sqlstate);
+  /* The rest of statement members was zeroed inside malloc */
+
+  init_alloc_root(PSI_NOT_INSTRUMENTED, &stmt->extension->fields_mem_root, 2048,
+                  0);
+
+  DBUG_RETURN(stmt);
+}
+
+/*
+  Prepare server side statement with query.
+
+  SYNOPSIS
+    mysql_stmt_prepare()
+    stmt    statement handle
+    query   statement to prepare
+    length  statement length
+
+  DESCRIPTION
+    Associate statement with statement handle. This is done both on
+    client and server sides. At this point the server parses given query
+    and creates an internal structure to represent it.
+    Next steps you may want to make:
+    - find out if this statement returns a result set by
+      calling mysql_stmt_field_count(), and get result set metadata
+      with mysql_stmt_result_metadata(),
+    - if query contains placeholders, bind input parameters to placeholders
+      using mysql_stmt_bind_param(),
+    - otherwise proceed directly to mysql_stmt_execute().
+
+  IMPLEMENTATION NOTES
+  - if this is a re-prepare of the statement, first close previous data
+    structure on the server and free old statement data
+  - then send the query to server and get back number of placeholders,
+    number of columns in result set (if any), and result set metadata.
+    At the same time allocate memory for input and output parameters
+    to have less checks in mysql_stmt_bind_{param, result}.
+
+  RETURN VALUES
+    0  success
+   !0  error
+*/
+
+int STDCALL mysql_stmt_prepare(MYSQL_STMT *stmt, const char *query,
+                               ulong length) {
+  MYSQL *mysql = stmt->mysql;
+  DBUG_ENTER("mysql_stmt_prepare");
+
+  if (!mysql) {
+    /* mysql can be reset in mysql_close called from mysql_reconnect */
+    set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  /*
+    Reset the last error in any case: that would clear the statement
+    if the previous prepare failed.
+  */
+  stmt->last_errno = 0;
+  stmt->last_error[0] = '\0';
+
+  if ((int)stmt->state > (int)MYSQL_STMT_INIT_DONE) {
+    /* This is second prepare with another statement */
+    uchar buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */
+
+    if (reset_stmt_handle(stmt, RESET_LONG_DATA | RESET_STORE_RESULT))
+      DBUG_RETURN(1);
+    /*
+      These members must be reset for API to
+      function in case of error or misuse.
+    */
+    stmt->bind_param_done = false;
+    stmt->bind_result_done = false;
+    stmt->param_count = stmt->field_count = 0;
+    free_root(stmt->mem_root, MYF(MY_KEEP_PREALLOC));
+    free_root(&stmt->extension->fields_mem_root, MYF(0));
+
+    int4store(buff, stmt->stmt_id);
+
+    /*
+      Close statement in server
+
+      If there was a 'use' result from another statement, or from
+      mysql_use_result it won't be freed in mysql_stmt_free_result and
+      we should get 'Commands out of sync' here.
+    */
+    stmt->state = MYSQL_STMT_INIT_DONE;
+    if (stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt)) {
+      set_stmt_errmsg(stmt, &mysql->net);
+      DBUG_RETURN(1);
+    }
+  }
+
+  if (stmt_command(mysql, COM_STMT_PREPARE, (const uchar *)query, length,
+                   stmt)) {
+    set_stmt_errmsg(stmt, &mysql->net);
+    DBUG_RETURN(1);
+  }
+
+  if ((*mysql->methods->read_prepare_result)(mysql, stmt)) {
+    set_stmt_errmsg(stmt, &mysql->net);
+    DBUG_RETURN(1);
+  }
+
+  /*
+    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->params = (MYSQL_BIND *)stmt->mem_root->Alloc(
+            sizeof(MYSQL_BIND) * (stmt->param_count + stmt->field_count)))) {
+    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+  stmt->bind = stmt->params + stmt->param_count;
+  stmt->state = MYSQL_STMT_PREPARE_DONE;
+  DBUG_PRINT("info", ("Parameter count: %u", stmt->param_count));
+  DBUG_RETURN(0);
+}
+
+/*
+  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) {
+  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));
+
+  /*
+    mysql->fields is NULL when the client set CLIENT_OPTIONAL_RESULTSET_METADATA
+    flag and server @@session.resultset_metadata is "NONE". That means that the
+    client received a resultset without metadata.
+  */
+  if (!mysql->fields) return;
+
+  /*
+    Get the field information for non-select statements
+    like SHOW and DESCRIBE commands
+  */
+  if (!(stmt->fields = (MYSQL_FIELD *)fields_mem_root->Alloc(
+            sizeof(MYSQL_FIELD) * stmt->field_count)) ||
+      !(stmt->bind = (MYSQL_BIND *)fields_mem_root->Alloc(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++) {
+    *field = *fields; /* To copy all numeric parts. */
+    field->catalog =
+        strmake_root(fields_mem_root, fields->catalog, fields->catalog_length);
+    field->db = strmake_root(fields_mem_root, fields->db, fields->db_length);
+    field->table =
+        strmake_root(fields_mem_root, fields->table, fields->table_length);
+    field->org_table = strmake_root(fields_mem_root, fields->org_table,
+                                    fields->org_table_length);
+    field->name =
+        strmake_root(fields_mem_root, fields->name, fields->name_length);
+    field->org_name = strmake_root(fields_mem_root, fields->org_name,
+                                   fields->org_name_length);
+    if (fields->def) {
+      field->def =
+          strmake_root(fields_mem_root, fields->def, fields->def_length);
+      field->def_length = fields->def_length;
+    } else {
+      field->def = NULL;
+      field->def_length = 0;
+    }
+    field->extension = 0;  /* Avoid dangling links. */
+    field->max_length = 0; /* max_length is set in mysql_stmt_store_result() */
+  }
+}
+
+/**
+  Update result set columns metadata if it was sent again in
+  reply to COM_STMT_EXECUTE.
+
+  @note If the new field count is different from the original one,
+        an error is set and no update is performed.
+*/
+
+static void update_stmt_fields(MYSQL_STMT *stmt) {
+  MYSQL_FIELD *field = stmt->mysql->fields;
+  MYSQL_FIELD *field_end = field + stmt->field_count;
+  MYSQL_FIELD *stmt_field = stmt->fields;
+  MYSQL_BIND *my_bind = stmt->bind_result_done ? stmt->bind : 0;
+
+  if (stmt->field_count != stmt->mysql->field_count) {
+    /*
+      The tables used in the statement were altered,
+      and the query now returns a different number of columns.
+      There is no way to continue without reallocating the bind
+      array:
+      - if the number of columns increased, mysql_stmt_fetch()
+      will write beyond allocated memory
+      - if the number of columns decreased, some user-bound
+      buffers will be left unassigned without user knowing
+      that.
+    */
+    set_stmt_error(stmt, CR_NEW_STMT_METADATA, unknown_sqlstate, NULL);
+    return;
+  }
+
+  /*
+    mysql->fields is NULL when the client set CLIENT_OPTIONAL_RESULTSET_METADATA
+    flag and server @@session.resultset_metadata is "NONE". That means that the
+    client received a resultset without metadata.
+  */
+  if (!field) return;
+
+  for (; field < field_end; ++field, ++stmt_field) {
+    stmt_field->charsetnr = field->charsetnr;
+    stmt_field->length = field->length;
+    stmt_field->type = field->type;
+    stmt_field->flags = field->flags;
+    stmt_field->decimals = field->decimals;
+    if (my_bind) {
+      /* Ignore return value: it should be 0 if bind_result succeeded. */
+      (void)setup_one_fetch_function(my_bind++, stmt_field);
+    }
+  }
+}
+
+/*
+  Returns prepared statement metadata in the form of a result set.
+
+  SYNOPSIS
+    mysql_stmt_result_metadata()
+    stmt  statement handle
+
+  DESCRIPTION
+    This function should be used after mysql_stmt_execute().
+    You can safely check that prepared statement has a result set by calling
+    mysql_stmt_field_count(): if number of fields is not zero, you can call
+    this function to get fields metadata.
+    Next steps you may want to make:
+    - find out number of columns in result set by calling
+      mysql_num_fields(res) (the same value is returned by
+      mysql_stmt_field_count())
+    - fetch metadata for any column with mysql_fetch_field,
+      mysql_fetch_field_direct, mysql_fetch_fields, mysql_field_seek.
+    - free returned MYSQL_RES structure with mysql_free_result.
+    - proceed to binding of output parameters.
+
+  RETURN
+    NULL  statement contains no result set or out of memory.
+          In the latter case you can retreive error message
+          with mysql_stmt_error.
+    MYSQL_RES  a result set with no rows
+*/
+
+MYSQL_RES *STDCALL mysql_stmt_result_metadata(MYSQL_STMT *stmt) {
+  MYSQL_RES *result;
+  DBUG_ENTER("mysql_stmt_result_metadata");
+
+  /*
+    stmt->fields is only defined if stmt->field_count is not null;
+    stmt->field_count is initialized in prepare.
+  */
+  if (!stmt->field_count) DBUG_RETURN(0);
+
+  if (!(result = (MYSQL_RES *)my_malloc(PSI_NOT_INSTRUMENTED, sizeof(*result),
+                                        MYF(MY_WME | MY_ZEROFILL)))) {
+    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+    DBUG_RETURN(0);
+  }
+
+  result->methods = stmt->mysql->methods;
+  result->eof = 1; /* Marker for buffered */
+  result->fields = stmt->fields;
+  result->field_count = stmt->field_count;
+  /* The rest of members of 'result' was zeroed inside malloc */
+  DBUG_RETURN(result);
+}
+
+/*
+  Returns parameter columns meta information in the form of
+  result set.
+
+  SYNOPSYS
+    mysql_stmt_param_metadata()
+    stmt    statement handle
+
+  DESCRIPTION
+    This function can be called after you prepared the statement handle
+    with mysql_stmt_prepare().
+    XXX: not implemented yet.
+
+  RETURN
+    MYSQL_RES on success, 0 if there is no metadata.
+    Currently this function always returns 0.
+*/
+
+MYSQL_RES *STDCALL mysql_stmt_param_metadata(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_param_metadata");
+
+  if (!stmt->param_count) DBUG_RETURN(0);
+
+  /*
+    TODO: Fix this when server sends the information.
+    Till then keep a dummy prototype.
+  */
+  DBUG_RETURN(0);
+}
+
+/* Store type of parameter in network buffer. */
+
+static void store_param_type(unsigned char **pos, MYSQL_BIND *param) {
+  uint typecode = param->buffer_type | (param->is_unsigned ? 32768 : 0);
+  int2store(*pos, typecode);
+  *pos += 2;
+}
+
+/*
+  Functions to store parameter data in network packet.
+
+  SYNOPSIS
+    store_param_xxx()
+    net			MySQL NET connection
+    param		MySQL bind param
+
+  DESCRIPTION
+    These funtions are invoked from mysql_stmt_execute() by
+    MYSQL_BIND::store_param_func pointer. This pointer is set once per
+    many executions in mysql_stmt_bind_param(). The caller must ensure
+    that network buffer have enough capacity to store parameter
+    (MYSQL_BIND::buffer_length contains needed number of bytes).
+*/
+
+static void store_param_tinyint(NET *net, MYSQL_BIND *param) {
+  *(net->write_pos++) = *(uchar *)param->buffer;
+}
+
+static void store_param_short(NET *net, MYSQL_BIND *param) {
+  short value = *(short *)param->buffer;
+  int2store(net->write_pos, value);
+  net->write_pos += 2;
+}
+
+static void store_param_int32(NET *net, MYSQL_BIND *param) {
+  int32 value = *(int32 *)param->buffer;
+  int4store(net->write_pos, value);
+  net->write_pos += 4;
+}
+
+static void store_param_int64(NET *net, MYSQL_BIND *param) {
+  longlong value = *(longlong *)param->buffer;
+  int8store(net->write_pos, value);
+  net->write_pos += 8;
+}
+
+static void store_param_float(NET *net, MYSQL_BIND *param) {
+  float value = *(float *)param->buffer;
+  float4store(net->write_pos, value);
+  net->write_pos += 4;
+}
+
+static void store_param_double(NET *net, MYSQL_BIND *param) {
+  double value = *(double *)param->buffer;
+  float8store(net->write_pos, value);
+  net->write_pos += 8;
+}
+
+static void store_param_time(NET *net, MYSQL_BIND *param) {
+  MYSQL_TIME *tm = (MYSQL_TIME *)param->buffer;
+  uchar buff[MAX_TIME_REP_LENGTH], *pos;
+  uint length;
+
+  pos = buff + 1;
+  pos[0] = tm->neg ? 1 : 0;
+  int4store(pos + 1, tm->day);
+  pos[5] = (uchar)tm->hour;
+  pos[6] = (uchar)tm->minute;
+  pos[7] = (uchar)tm->second;
+  int4store(pos + 8, tm->second_part);
+  if (tm->second_part)
+    length = 12;
+  else if (tm->hour || tm->minute || tm->second || tm->day)
+    length = 8;
+  else
+    length = 0;
+  buff[0] = (char)length++;
+  memcpy((char *)net->write_pos, buff, length);
+  net->write_pos += length;
+}
+
+static void net_store_datetime(NET *net, MYSQL_TIME *tm) {
+  uchar buff[MAX_DATETIME_REP_LENGTH], *pos;
+  uint length;
+
+  pos = buff + 1;
+
+  int2store(pos, tm->year);
+  pos[2] = (uchar)tm->month;
+  pos[3] = (uchar)tm->day;
+  pos[4] = (uchar)tm->hour;
+  pos[5] = (uchar)tm->minute;
+  pos[6] = (uchar)tm->second;
+  int4store(pos + 7, tm->second_part);
+  if (tm->second_part)
+    length = 11;
+  else if (tm->hour || tm->minute || tm->second)
+    length = 7;
+  else if (tm->year || tm->month || tm->day)
+    length = 4;
+  else
+    length = 0;
+  buff[0] = (char)length++;
+  memcpy((char *)net->write_pos, buff, length);
+  net->write_pos += length;
+}
+
+static void store_param_date(NET *net, MYSQL_BIND *param) {
+  MYSQL_TIME tm = *((MYSQL_TIME *)param->buffer);
+  tm.hour = tm.minute = tm.second = tm.second_part = 0;
+  net_store_datetime(net, &tm);
+}
+
+static void store_param_datetime(NET *net, MYSQL_BIND *param) {
+  MYSQL_TIME *tm = (MYSQL_TIME *)param->buffer;
+  net_store_datetime(net, tm);
+}
+
+static void store_param_str(NET *net, MYSQL_BIND *param) {
+  /* param->length is always set in mysql_stmt_bind_param */
+  ulong length = *param->length;
+  uchar *to = net_store_length(net->write_pos, length);
+  memcpy(to, param->buffer, length);
+  net->write_pos = to + length;
+}
+
+/*
+  Mark if the parameter is NULL.
+
+  SYNOPSIS
+    store_param_null()
+    net			MySQL NET connection
+    param		MySQL bind param
+
+  DESCRIPTION
+    A data package starts with a string of bits where we set a bit
+    if a parameter is NULL. Unlike bit string in result set row, here
+    we don't have reserved bits for OK/error packet.
+*/
+
+static void store_param_null(NET *net, MYSQL_BIND *param) {
+  uint pos = param->param_number;
+  net->buff[pos / 8] |= (uchar)(1 << (pos & 7));
+}
+
+/*
+  Store one parameter in network packet: data is read from
+  client buffer and saved in network packet by means of one
+  of store_param_xxxx functions.
+*/
+
+static bool store_param(MYSQL_STMT *stmt, MYSQL_BIND *param) {
+  NET *net = &stmt->mysql->net;
+  DBUG_ENTER("store_param");
+  DBUG_PRINT("enter",
+             ("type: %d  buffer: %p  length: %lu  is_null: %d",
+              param->buffer_type, (param->buffer ? param->buffer : NullS),
+              *param->length, *param->is_null));
+
+  if (*param->is_null)
+    store_param_null(net, param);
+  else {
+    /*
+      Param->length should ALWAYS point to the correct length for the type
+      Either to the length pointer given by the user or param->buffer_length
+    */
+    if ((my_realloc_str(net, *param->length))) {
+      set_stmt_errmsg(stmt, net);
+      DBUG_RETURN(1);
+    }
+    (*param->store_param_func)(net, param);
+  }
+  DBUG_RETURN(0);
+}
+
+static inline int add_binary_row(NET *net, MYSQL_STMT *stmt, ulong pkt_len,
+                                 MYSQL_ROWS ***prev_ptr) {
+  MYSQL_ROWS *row;
+  uchar *cp = net->read_pos;
+  MYSQL_DATA *result = &stmt->result;
+  if (!(row = (MYSQL_ROWS *)result->alloc->Alloc(sizeof(MYSQL_ROWS) + pkt_len -
+                                                 1))) {
+    set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+    return 1;
+  }
+  row->data = (MYSQL_ROW)(row + 1);
+  **prev_ptr = row;
+  *prev_ptr = &row->next;
+  memcpy((char *)row->data, (char *)cp + 1, pkt_len - 1);
+  row->length = pkt_len; /* To allow us to do sanity checks */
+  result->rows++;
+  return 0;
+}
+
+/*
+  Auxilary function to send COM_STMT_EXECUTE packet to server and read reply.
+  Used from cli_stmt_execute, which is in turn used by mysql_stmt_execute.
+*/
+
+static bool execute(MYSQL_STMT *stmt, char *packet, ulong length) {
+  MYSQL *mysql = stmt->mysql;
+  NET *net = &mysql->net;
+  uchar buff[4 /* size of stmt id */ + 5 /* execution flags */];
+  bool res;
+  bool is_data_packet = false;
+  ulong pkt_len;
+  MYSQL_ROWS **prev_ptr = NULL;
+  DBUG_ENTER("execute");
+  DBUG_DUMP("packet", (uchar *)packet, length);
+
+  int4store(buff, stmt->stmt_id); /* Send stmt id to server */
+  buff[4] = (char)stmt->flags;
+  int4store(buff + 5, 1); /* iteration count */
+
+  res = (cli_advanced_command(mysql, COM_STMT_EXECUTE, buff, sizeof(buff),
+                              (uchar *)packet, length, 1, stmt) ||
+         (*mysql->methods->read_query_result)(mysql));
+
+  if ((mysql->server_capabilities & CLIENT_DEPRECATE_EOF)) {
+    if (mysql->server_status & SERVER_STATUS_CURSOR_EXISTS)
+      mysql->server_status &= ~SERVER_STATUS_CURSOR_EXISTS;
+
+    /*
+      After having read the query result, we need to make sure that the client
+      does not end up into a hang waiting for the server to send a packet.
+      If the CURSOR_TYPE_READ_ONLY flag is set, we would want to perform the
+      additional packet read mainly for prepared statements involving SELECT
+      queries. For SELECT queries, the result format would either be
+      <Metadata><OK> or <Metadata><rows><OK>. We would have read the metadata
+      by now and have the field_count populated. The check for field_count will
+      help determine if we can expect an additional packet from the server.
+    */
+
+    if (!res && (stmt->flags & CURSOR_TYPE_READ_ONLY) &&
+        mysql->field_count != 0) {
+      /*
+        server can now respond with a cursor - then the respond will be
+        <Metadata><OK> or with binary rows result set <Metadata><row(s)><OK>.
+        The former can be the case when the prepared statement is a procedure
+        invocation, ie. call(). There also other cases. When server responds
+        with <OK> (cursor) packet we read it and get the server status. In case
+        it responds with binary row we add it to the binary rows result set
+        (the reset of the result set will be read in prepare_to_fetch_result).
+      */
+
+      if ((pkt_len = cli_safe_read(mysql, &is_data_packet)) == packet_error)
+        DBUG_RETURN(1);
+
+      if (is_data_packet) {
+        DBUG_ASSERT(stmt->result.rows == 0);
+        prev_ptr = &stmt->result.data;
+        if (add_binary_row(net, stmt, pkt_len, &prev_ptr)) DBUG_RETURN(1);
+      } else {
+        read_ok_ex(mysql, pkt_len);
+        /*
+          If the result set was empty and the server did not open a cursor,
+          then the response from the server would have been <metadata><OK>.
+          This means the OK packet read above was the last OK packet of the
+          sequence. Hence, we set the status to indicate that the client is
+          now ready for next command. The stmt->read_row_func is set so as
+          to ensure that the next call to C API mysql_stmt_fetch() will not
+          read on the network. Instead, it will return NO_MORE_DATA.
+        */
+        if (!(mysql->server_status & SERVER_STATUS_CURSOR_EXISTS)) {
+          mysql->status = MYSQL_STATUS_READY;
+          stmt->read_row_func = stmt_read_row_no_data;
+        }
+      }
+    }
+  }
+
+  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);
+}
+
+int cli_stmt_execute(MYSQL_STMT *stmt) {
+  DBUG_ENTER("cli_stmt_execute");
+
+  if (stmt->param_count) {
+    MYSQL *mysql = stmt->mysql;
+    NET *net = &mysql->net;
+    MYSQL_BIND *param, *param_end;
+    char *param_data;
+    ulong length;
+    uint null_count;
+    bool result;
+
+    if (!stmt->bind_param_done) {
+      set_stmt_error(stmt, CR_PARAMS_NOT_BOUND, unknown_sqlstate, NULL);
+      DBUG_RETURN(1);
+    }
+    if (mysql->status != MYSQL_STATUS_READY ||
+        mysql->server_status & SERVER_MORE_RESULTS_EXISTS) {
+      set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate, NULL);
+      DBUG_RETURN(1);
+    }
+
+    if (net->vio)
+      net_clear(net, 1); /* Sets net->write_pos */
+    else {
+      set_stmt_errmsg(stmt, net);
+      DBUG_RETURN(1);
+    }
+
+    /* Reserve place for null-marker bytes */
+    null_count = (stmt->param_count + 7) / 8;
+    if (my_realloc_str(net, null_count + 1)) {
+      set_stmt_errmsg(stmt, net);
+      DBUG_RETURN(1);
+    }
+    memset(net->write_pos, 0, null_count);
+    net->write_pos += null_count;
+    param_end = stmt->params + stmt->param_count;
+
+    /* In case if buffers (type) altered, indicate to server */
+    *(net->write_pos)++ = (uchar)stmt->send_types_to_server;
+    if (stmt->send_types_to_server) {
+      if (my_realloc_str(net, 2 * stmt->param_count)) {
+        set_stmt_errmsg(stmt, net);
+        DBUG_RETURN(1);
+      }
+      /*
+        Store types of parameters in first in first package
+        that is sent to the server.
+      */
+      for (param = stmt->params; param < param_end; param++)
+        store_param_type(&net->write_pos, param);
+    }
+
+    for (param = stmt->params; param < param_end; param++) {
+      /* check if mysql_stmt_send_long_data() was used */
+      if (param->long_data_used)
+        param->long_data_used = 0; /* Clear for next execute call */
+      else if (store_param(stmt, param))
+        DBUG_RETURN(1);
+    }
+    length = (ulong)(net->write_pos - net->buff);
+    /* TODO: Look into avoding the following memdup */
+    if (!(param_data = pointer_cast<char *>(
+              my_memdup(PSI_NOT_INSTRUMENTED, net->buff, length, MYF(0))))) {
+      set_stmt_error(stmt, CR_OUT_OF_MEMORY, unknown_sqlstate, NULL);
+      DBUG_RETURN(1);
+    }
+    result = execute(stmt, param_data, length);
+    stmt->send_types_to_server = 0;
+    my_free(param_data);
+    DBUG_RETURN(result);
+  }
+  DBUG_RETURN((int)execute(stmt, 0, 0));
+}
+
+/*
+  Read one row from buffered result set.  Result set is created by prior
+  call to mysql_stmt_store_result().
+  SYNOPSIS
+    stmt_read_row_buffered()
+
+  RETURN VALUE
+    0             - success; *row is set to valid row pointer (row data
+                    is stored in result set buffer)
+    MYSQL_NO_DATA - end of result set. *row is set to NULL
+*/
+
+static int stmt_read_row_buffered(MYSQL_STMT *stmt, unsigned char **row) {
+  if (stmt->data_cursor) {
+    *row = (uchar *)stmt->data_cursor->data;
+    stmt->data_cursor = stmt->data_cursor->next;
+    return 0;
+  }
+  *row = 0;
+  return MYSQL_NO_DATA;
+}
+
+/*
+  Read one row from network: unbuffered non-cursor fetch.
+  If last row was read, or error occurred, erase this statement
+  from record pointing to object unbuffered fetch is performed from.
+
+  SYNOPSIS
+    stmt_read_row_unbuffered()
+    stmt  statement handle
+    row   pointer to write pointer to row data;
+
+  RETURN VALUE
+    0           - success; *row contains valid address of a row;
+                  row data is stored in network buffer
+    1           - error; error code is written to
+                  stmt->last_{errno,error}; *row is not changed
+  MYSQL_NO_DATA - end of file was read from network;
+                  *row is set to NULL
+*/
+
+static int stmt_read_row_unbuffered(MYSQL_STMT *stmt, unsigned char **row) {
+  int rc = 1;
+  MYSQL *mysql = stmt->mysql;
+  /*
+    This function won't be called if stmt->field_count is zero
+    or execution wasn't done: this is ensured by mysql_stmt_execute.
+  */
+  if (!mysql) {
+    set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL);
+    return 1;
+  }
+  if (mysql->status != MYSQL_STATUS_STATEMENT_GET_RESULT) {
+    set_stmt_error(stmt,
+                   stmt->unbuffered_fetch_cancelled ? CR_FETCH_CANCELED
+                                                    : CR_COMMANDS_OUT_OF_SYNC,
+                   unknown_sqlstate, NULL);
+    goto error;
+  }
+  if ((*mysql->methods->unbuffered_fetch)(mysql, (char **)row)) {
+    set_stmt_errmsg(stmt, &mysql->net);
+    /*
+      If there was an error, there are no more pending rows:
+      reset statement status to not hang up in following
+      mysql_stmt_close (it will try to flush result set before
+      closing the statement).
+    */
+    mysql->status = MYSQL_STATUS_READY;
+    goto error;
+  }
+  if (!*row) {
+    mysql->status = MYSQL_STATUS_READY;
+    rc = MYSQL_NO_DATA;
+    goto error;
+  }
+  return 0;
+error:
+  if (mysql->unbuffered_fetch_owner == &stmt->unbuffered_fetch_cancelled)
+    mysql->unbuffered_fetch_owner = 0;
+  return rc;
+}
+
+/*
+  Fetch statement row using server side cursor.
+
+  SYNOPSIS
+    stmt_read_row_from_cursor()
+
+  RETURN VALUE
+    0            success
+    1            error
+  MYSQL_NO_DATA  end of data
+*/
+
+static int stmt_read_row_from_cursor(MYSQL_STMT *stmt, unsigned char **row) {
+  if (stmt->data_cursor) return stmt_read_row_buffered(stmt, row);
+  if (stmt->server_status & SERVER_STATUS_LAST_ROW_SENT)
+    stmt->server_status &= ~SERVER_STATUS_LAST_ROW_SENT;
+  else {
+    MYSQL *mysql = stmt->mysql;
+    NET *net = &mysql->net;
+    MYSQL_DATA *result = &stmt->result;
+    uchar buff[4 /* statement id */ + 4 /* number of rows to fetch */];
+
+    free_root(result->alloc, MYF(MY_KEEP_PREALLOC));
+    result->data = NULL;
+    result->rows = 0;
+    /* Send row request to the server */
+    int4store(buff, stmt->stmt_id);
+    int4store(buff + 4, stmt->prefetch_rows); /* number of rows to fetch */
+    if ((*mysql->methods->advanced_command)(mysql, COM_STMT_FETCH, buff,
+                                            sizeof(buff), (uchar *)0, 0, 1,
+                                            stmt)) {
+      /*
+        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);
+      return 1;
+    }
+    if ((*mysql->methods->read_rows_from_cursor)(stmt)) return 1;
+    stmt->server_status = mysql->server_status;
+
+    stmt->data_cursor = result->data;
+    return stmt_read_row_buffered(stmt, row);
+  }
+  *row = 0;
+  return MYSQL_NO_DATA;
+}
+
+/*
+  Default read row function to not SIGSEGV in client in
+  case of wrong sequence of API calls.
+*/
+
+static int stmt_read_row_no_data(MYSQL_STMT *stmt MY_ATTRIBUTE((unused)),
+                                 unsigned char **row MY_ATTRIBUTE((unused))) {
+  return MYSQL_NO_DATA;
+}
+
+static int stmt_read_row_no_result_set(MYSQL_STMT *stmt MY_ATTRIBUTE((unused)),
+                                       unsigned char **row
+                                           MY_ATTRIBUTE((unused))) {
+  set_stmt_error(stmt, CR_NO_RESULT_SET, unknown_sqlstate, NULL);
+  return 1;
+}
+
+/*
+  Get/set statement attributes
+
+  SYNOPSIS
+    mysql_stmt_attr_get()
+    mysql_stmt_attr_set()
+
+    attr_type  statement attribute
+    value      casted to const void * pointer to value.
+
+  RETURN VALUE
+    0 success
+   !0 wrong attribute type
+*/
+
+bool STDCALL mysql_stmt_attr_set(MYSQL_STMT *stmt,
+                                 enum enum_stmt_attr_type attr_type,
+                                 const void *value) {
+  switch (attr_type) {
+    case STMT_ATTR_UPDATE_MAX_LENGTH:
+      stmt->update_max_length = value ? *(const bool *)value : 0;
+      break;
+    case STMT_ATTR_CURSOR_TYPE: {
+      ulong cursor_type;
+      cursor_type = value ? *static_cast<const ulong *>(value) : 0UL;
+      if (cursor_type > (ulong)CURSOR_TYPE_READ_ONLY) goto err_not_implemented;
+      stmt->flags = cursor_type;
+      break;
+    }
+    case STMT_ATTR_PREFETCH_ROWS: {
+      ulong prefetch_rows =
+          value ? *static_cast<const ulong *>(value) : DEFAULT_PREFETCH_ROWS;
+      if (value == 0) return true;
+      stmt->prefetch_rows = prefetch_rows;
+      break;
+    }
+    default:
+      goto err_not_implemented;
+  }
+  return false;
+err_not_implemented:
+  set_stmt_error(stmt, CR_NOT_IMPLEMENTED, unknown_sqlstate, NULL);
+  return true;
+}
+
+bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt,
+                                 enum enum_stmt_attr_type attr_type,
+                                 void *value) {
+  switch (attr_type) {
+    case STMT_ATTR_UPDATE_MAX_LENGTH:
+      *(bool *)value = stmt->update_max_length;
+      break;
+    case STMT_ATTR_CURSOR_TYPE:
+      *(ulong *)value = stmt->flags;
+      break;
+    case STMT_ATTR_PREFETCH_ROWS:
+      *(ulong *)value = stmt->prefetch_rows;
+      break;
+    default:
+      return true;
+  }
+  return false;
+}
+
+/**
+  Update statement result set metadata from with the new field
+  information sent during statement execute.
+
+  @pre mysql->field_count is not zero
+*/
+
+static void reinit_result_set_metadata(MYSQL_STMT *stmt) {
+  /* Server has sent result set metadata */
+  if (stmt->field_count == 0) {
+    /*
+      This is 'SHOW'/'EXPLAIN'-like query. Current implementation of
+      prepared statements can't send result set metadata for these queries
+      on prepare stage. Read it now.
+    */
+
+    stmt->field_count = stmt->mysql->field_count;
+
+    alloc_stmt_fields(stmt);
+  } else {
+    /*
+      Update result set metadata if it for some reason changed between
+      prepare and execute, i.e.:
+      - in case of 'SELECT ?' we don't know column type unless data was
+      supplied to mysql_stmt_execute, so updated column type is sent
+      now.
+      - if data dictionary changed between prepare and execute, for
+      example a table used in the query was altered.
+      Note, that now (4.1.3) we always send metadata in reply to
+      COM_STMT_EXECUTE (even if it is not necessary), so either this or
+      previous branch always works.
+      TODO: send metadata only when it's really necessary and add a warning
+      'Metadata changed' when it's sent twice.
+    */
+    update_stmt_fields(stmt);
+  }
+}
+
+static void prepare_to_fetch_result(MYSQL_STMT *stmt) {
+  if (stmt->server_status & SERVER_STATUS_CURSOR_EXISTS) {
+    stmt->mysql->status = MYSQL_STATUS_READY;
+    stmt->read_row_func = stmt_read_row_from_cursor;
+  } else if (stmt->flags & CURSOR_TYPE_READ_ONLY) {
+    /*
+      This is a single-row result set, a result set with no rows, EXPLAIN,
+      SHOW VARIABLES, or some other command which either a) bypasses the
+      cursors framework in the server and writes rows directly to the
+      network or b) is more efficient if all (few) result set rows are
+      precached on client and server's resources are freed.
+      The below check for mysql->status is required because we could
+      have already read the last packet sent by the server in execute()
+      and set the status to MYSQL_STATUS_READY. In such cases, we need
+      not call mysql_stmt_store_result().
+    */
+    if (stmt->mysql->status != MYSQL_STATUS_READY)
+      mysql_stmt_store_result(stmt);
+  } else {
+    stmt->mysql->unbuffered_fetch_owner = &stmt->unbuffered_fetch_cancelled;
+    stmt->unbuffered_fetch_cancelled = false;
+    stmt->read_row_func = stmt_read_row_unbuffered;
+  }
+}
+
+/*
+  Send placeholders data to server (if there are placeholders)
+  and execute prepared statement.
+
+  SYNOPSIS
+    mysql_stmt_execute()
+    stmt  statement handle. The handle must be created
+          with mysql_stmt_init() and prepared with
+          mysql_stmt_prepare(). If there are placeholders
+          in the statement they must be bound to local
+          variables with mysql_stmt_bind_param().
+
+  DESCRIPTION
+    This function will automatically flush pending result
+    set (if there is one), send parameters data to the server
+    and read result of statement execution.
+    If previous result set was cached with mysql_stmt_store_result()
+    it will also be freed in the beginning of this call.
+    The server can return 3 types of responses to this command:
+    - error, can be retrieved with mysql_stmt_error()
+    - ok, no result set pending. In this case we just update
+      stmt->insert_id and stmt->affected_rows.
+    - the query returns a result set: there could be 0 .. N
+    rows in it. In this case the server can also send updated
+    result set metadata.
+
+    Next steps you may want to make:
+    - find out if there is result set with mysql_stmt_field_count().
+    If there is one:
+    - optionally, cache entire result set on client to unblock
+    connection with mysql_stmt_store_result()
+    - bind client variables to result set columns and start read rows
+    with mysql_stmt_fetch().
+    - reset statement with mysql_stmt_reset() or close it with
+    mysql_stmt_close()
+    Otherwise:
+    - find out last insert id and number of affected rows with
+    mysql_stmt_insert_id(), mysql_stmt_affected_rows()
+
+  RETURN
+    0   success
+    1   error, message can be retrieved with mysql_stmt_error().
+*/
+
+int STDCALL mysql_stmt_execute(MYSQL_STMT *stmt) {
+  MYSQL *mysql = stmt->mysql;
+  DBUG_ENTER("mysql_stmt_execute");
+
+  if (!mysql) {
+    /* Error is already set in mysql_detatch_stmt_list */
+    DBUG_RETURN(1);
+  }
+
+  if (reset_stmt_handle(stmt, RESET_STORE_RESULT | RESET_CLEAR_ERROR))
+    DBUG_RETURN(1);
+  /*
+    No need to check for stmt->state: if the statement wasn't
+    prepared we'll get 'unknown statement handler' error from server.
+  */
+  if (mysql->methods->stmt_execute(stmt)) DBUG_RETURN(1);
+  stmt->state = MYSQL_STMT_EXECUTE_DONE;
+  if (mysql->field_count) {
+    reinit_result_set_metadata(stmt);
+    prepare_to_fetch_result(stmt);
+  }
+  DBUG_RETURN(stmt->last_errno != 0);
+}
+
+/*
+  Return total parameters count in the statement
+*/
+
+ulong STDCALL mysql_stmt_param_count(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_param_count");
+  DBUG_RETURN(stmt->param_count);
+}
+
+/*
+  Return total affected rows from the last statement
+*/
+
+my_ulonglong STDCALL mysql_stmt_affected_rows(MYSQL_STMT *stmt) {
+  return stmt->affected_rows;
+}
+
+/*
+  Returns the number of result columns for the most recent query
+  run on this statement.
+*/
+
+unsigned int STDCALL mysql_stmt_field_count(MYSQL_STMT *stmt) {
+  return stmt->field_count;
+}
+
+/*
+  Return last inserted id for auto_increment columns.
+
+  SYNOPSIS
+    mysql_stmt_insert_id()
+    stmt    statement handle
+
+  DESCRIPTION
+    Current implementation of this call has a caveat: stmt->insert_id is
+    unconditionally updated from mysql->insert_id in the end of each
+    mysql_stmt_execute(). This works OK if mysql->insert_id contains new
+    value (sent in reply to mysql_stmt_execute()), otherwise stmt->insert_id
+    value gets undefined, as it's updated from some arbitrary value saved in
+    connection structure during some other call.
+*/
+
+my_ulonglong STDCALL mysql_stmt_insert_id(MYSQL_STMT *stmt) {
+  return stmt->insert_id;
+}
+
+static bool int_is_null_true = 1; /* Used for MYSQL_TYPE_NULL */
+static bool int_is_null_false = 0;
+
+/*
+  Set up input data buffers for a statement.
+
+  SYNOPSIS
+    mysql_stmt_bind_param()
+    stmt    statement handle
+            The statement must be prepared with mysql_stmt_prepare().
+    my_bind Array of mysql_stmt_param_count() bind parameters.
+            This function doesn't check that size of this argument
+            is >= mysql_stmt_field_count(): it's user's responsibility.
+
+  DESCRIPTION
+    Use this call after mysql_stmt_prepare() to bind user variables to
+    placeholders.
+    Each element of bind array stands for a placeholder. Placeholders
+    are counted from 0.  For example statement
+    'INSERT INTO t (a, b) VALUES (?, ?)'
+    contains two placeholders, and for such statement you should supply
+    bind array of two elements (MYSQL_BIND bind[2]).
+
+    By properly initializing bind array you can bind virtually any
+    C language type to statement's placeholders:
+    First, it's strongly recommended to always zero-initialize entire
+    bind structure before setting its members. This will both shorten
+    your application code and make it robust to future extensions of
+    MYSQL_BIND structure.
+    Then you need to assign typecode of your application buffer to
+    MYSQL_BIND::buffer_type. The following typecodes with their
+    correspondence to C language types are supported:
+    MYSQL_TYPE_TINY       for 8-bit integer variables. Normally it's
+                          'signed char' and 'unsigned char';
+    MYSQL_TYPE_SHORT      for 16-bit signed and unsigned variables. This
+                          is usually 'short' and 'unsigned short';
+    MYSQL_TYPE_LONG       for 32-bit signed and unsigned variables. It
+                          corresponds to 'int' and 'unsigned int' on
+                          vast majority of platforms. On IA-32 and some
+                          other 32-bit systems you can also use 'long'
+                          here;
+    MYSQL_TYPE_LONGLONG   64-bit signed or unsigned integer.  Stands for
+                          '[unsigned] long long' on most platforms;
+    MYSQL_TYPE_FLOAT      32-bit floating point type, 'float' on most
+                          systems;
+    MYSQL_TYPE_DOUBLE     64-bit floating point type, 'double' on most
+                          systems;
+    MYSQL_TYPE_TIME       broken-down time stored in MYSQL_TIME
+                          structure
+    MYSQL_TYPE_DATE       date stored in MYSQL_TIME structure
+    MYSQL_TYPE_DATETIME   datetime stored in MYSQL_TIME structure See
+                          more on how to use these types for sending
+                          dates and times below;
+    MYSQL_TYPE_STRING     character string, assumed to be in
+                          character-set-client. If character set of
+                          client is not equal to character set of
+                          column, value for this placeholder will be
+                          converted to destination character set before
+                          insert.
+    MYSQL_TYPE_BLOB       sequence of bytes. This sequence is assumed to
+                          be in binary character set (which is the same
+                          as no particular character set), and is never
+                          converted to any other character set. See also
+                          notes about supplying string/blob length
+                          below.
+    MYSQL_TYPE_NULL       special typecode for binding nulls.
+    These C/C++ types are not supported yet by the API: long double,
+    bool.
+
+    As you can see from the list above, it's responsibility of
+    application programmer to ensure that chosen typecode properly
+    corresponds to host language type. For example on all platforms
+    where we build MySQL packages (as of MySQL 4.1.4) int is a 32-bit
+    type. So for int you can always assume that proper typecode is
+    MYSQL_TYPE_LONG (however queer it sounds, the name is legacy of the
+    old MySQL API). In contrary sizeof(long) can be 4 or 8 8-bit bytes,
+    depending on platform.
+
+    TODO: provide client typedefs for each integer and floating point
+    typecode, i. e. int8, uint8, float32, etc.
+
+    Once typecode was set, it's necessary to assign MYSQL_BIND::buffer
+    to point to the buffer of given type. Finally, additional actions
+    may be taken for some types or use cases:
+
+    Binding integer types.
+      For integer types you might also need to set MYSQL_BIND::is_unsigned
+      member. Set it to true when binding unsigned char, unsigned short,
+      unsigned int, unsigned long, unsigned long long.
+
+    Binding floating point types.
+      For floating point types you just need to set
+      MYSQL_BIND::buffer_type and MYSQL_BIND::buffer. The rest of the
+      members should be zero-initialized.
+
+    Binding NULLs.
+      You might have a column always NULL, never NULL, or sometimes
+      NULL.  For an always NULL column set MYSQL_BIND::buffer_type to
+      MYSQL_TYPE_NULL.  The rest of the members just need to be
+      zero-initialized.  For never NULL columns set
+      MYSQL_BIND::is_null to 0, or this has already been done if you
+      zero-initialized the entire structure.  If you set
+      MYSQL_TYPE::is_null to point to an application buffer of type
+      'bool', then this buffer will be checked on each execution:
+      this way you can set the buffer to true, or any non-0 value for
+      NULLs, and to false or 0 for not NULL data.
+
+    Binding text strings and sequences of bytes.
+      For strings, in addition to MYSQL_BIND::buffer_type and
+      MYSQL_BIND::buffer you need to set MYSQL_BIND::length or
+      MYSQL_BIND::buffer_length.  If 'length' is set, 'buffer_length'
+      is ignored. 'buffer_length' member should be used when size of
+      string doesn't change between executions. If you want to vary
+      buffer length for each value, set 'length' to point to an
+      application buffer of type 'unsigned long' and set this long to
+      length of the string before each mysql_stmt_execute().
+
+    Binding dates and times.
+      For binding dates and times prepared statements API provides
+      clients with MYSQL_TIME structure. A pointer to instance of this
+      structure should be assigned to MYSQL_BIND::buffer whenever
+      MYSQL_TYPE_TIME, MYSQL_TYPE_DATE, MYSQL_TYPE_DATETIME typecodes
+      are used.  When typecode is MYSQL_TYPE_TIME, only members
+      'hour', 'minute', 'second' and 'neg' (is time offset negative)
+      are used. These members only will be sent to the server.
+      MYSQL_TYPE_DATE implies use of 'year', 'month', 'day', 'neg'.
+      MYSQL_TYPE_DATETIME utilizes both parts of MYSQL_TIME structure.
+      You don't have to set MYSQL_TIME::time_type member: it's not
+      used when sending data to the server, typecode information is
+      enough.  'second_part' member can hold microsecond precision of
+      time value, but now it's only supported on protocol level: you
+      can't store microsecond in a column, or use in temporal
+      calculations. However, if you send a time value with microsecond
+      part for 'SELECT ?', statement, you'll get it back unchanged
+      from the server.
+
+    Data conversion.
+      If conversion from host language type to data representation,
+      corresponding to SQL type, is required it's done on the server.
+      Data truncation is possible when conversion is lossy. For
+      example, if you supply MYSQL_TYPE_DATETIME value out of valid
+      SQL type TIMESTAMP range, the same conversion will be applied as
+      if this value would have been sent as string in the old
+      protocol.  TODO: document how the server will behave in case of
+      truncation/data loss.
+
+    After variables were bound, you can repeatedly set/change their
+    values and mysql_stmt_execute() the statement.
+
+    See also: mysql_stmt_send_long_data() for sending long text/blob
+    data in pieces, examples in tests/mysql_client_test.c.
+    Next steps you might want to make:
+    - execute statement with mysql_stmt_execute(),
+    - reset statement using mysql_stmt_reset() or reprepare it with
+      another query using mysql_stmt_prepare()
+    - close statement with mysql_stmt_close().
+
+  IMPLEMENTATION
+    The function copies given bind array to internal storage of the
+    statement, and sets up typecode-specific handlers to perform
+    serialization of bound data. This means that although you don't need
+    to call this routine after each assignment to bind buffers, you
+    need to call it each time you change parameter typecodes, or other
+    members of MYSQL_BIND array.
+    This is a pure local call. Data types of client buffers are sent
+    along with buffers' data at first execution of the statement.
+
+  RETURN
+    0  success
+    1  error, can be retrieved with mysql_stmt_error.
+*/
+
+bool STDCALL mysql_stmt_bind_param(MYSQL_STMT *stmt, MYSQL_BIND *my_bind) {
+  uint count = 0;
+  MYSQL_BIND *param, *end;
+  DBUG_ENTER("mysql_stmt_bind_param");
+
+  if (!stmt->param_count) {
+    if ((int)stmt->state < (int)MYSQL_STMT_PREPARE_DONE) {
+      set_stmt_error(stmt, CR_NO_PREPARE_STMT, unknown_sqlstate, NULL);
+      DBUG_RETURN(1);
+    }
+    DBUG_RETURN(0);
+  }
+
+  /* Allocated on prepare */
+  memcpy((char *)stmt->params, (char *)my_bind,
+         sizeof(MYSQL_BIND) * stmt->param_count);
+
+  for (param = stmt->params, end = param + stmt->param_count; param < end;
+       param++) {
+    param->param_number = count++;
+    param->long_data_used = 0;
+
+    /* If param->is_null is not set, then the value can never be NULL */
+    if (!param->is_null) param->is_null = &int_is_null_false;
+
+    /* Setup data copy functions for the different supported types */
+    switch (param->buffer_type) {
+      case MYSQL_TYPE_NULL:
+        param->is_null = &int_is_null_true;
+        break;
+      case MYSQL_TYPE_TINY:
+        /* Force param->length as this is fixed for this type */
+        param->length = &param->buffer_length;
+        param->buffer_length = 1;
+        param->store_param_func = store_param_tinyint;
+        break;
+      case MYSQL_TYPE_SHORT:
+        param->length = &param->buffer_length;
+        param->buffer_length = 2;
+        param->store_param_func = store_param_short;
+        break;
+      case MYSQL_TYPE_LONG:
+        param->length = &param->buffer_length;
+        param->buffer_length = 4;
+        param->store_param_func = store_param_int32;
+        break;
+      case MYSQL_TYPE_LONGLONG:
+        param->length = &param->buffer_length;
+        param->buffer_length = 8;
+        param->store_param_func = store_param_int64;
+        break;
+      case MYSQL_TYPE_FLOAT:
+        param->length = &param->buffer_length;
+        param->buffer_length = 4;
+        param->store_param_func = store_param_float;
+        break;
+      case MYSQL_TYPE_DOUBLE:
+        param->length = &param->buffer_length;
+        param->buffer_length = 8;
+        param->store_param_func = store_param_double;
+        break;
+      case MYSQL_TYPE_TIME:
+        param->store_param_func = store_param_time;
+        param->buffer_length = MAX_TIME_REP_LENGTH;
+        break;
+      case MYSQL_TYPE_DATE:
+        param->store_param_func = store_param_date;
+        param->buffer_length = MAX_DATE_REP_LENGTH;
+        break;
+      case MYSQL_TYPE_DATETIME:
+      case MYSQL_TYPE_TIMESTAMP:
+        param->store_param_func = store_param_datetime;
+        param->buffer_length = MAX_DATETIME_REP_LENGTH;
+        break;
+      case MYSQL_TYPE_TINY_BLOB:
+      case MYSQL_TYPE_MEDIUM_BLOB:
+      case MYSQL_TYPE_LONG_BLOB:
+      case MYSQL_TYPE_BLOB:
+      case MYSQL_TYPE_VARCHAR:
+      case MYSQL_TYPE_VAR_STRING:
+      case MYSQL_TYPE_STRING:
+      case MYSQL_TYPE_DECIMAL:
+      case MYSQL_TYPE_NEWDECIMAL:
+      case MYSQL_TYPE_JSON:
+        param->store_param_func = store_param_str;
+        /*
+          For variable length types user must set either length or
+          buffer_length.
+        */
+        break;
+      default:
+        my_stpcpy(stmt->sqlstate, unknown_sqlstate);
+        sprintf(stmt->last_error,
+                ER_CLIENT(stmt->last_errno = CR_UNSUPPORTED_PARAM_TYPE),
+                param->buffer_type, count);
+        DBUG_RETURN(1);
+    }
+    /*
+      If param->length is not given, change it to point to buffer_length.
+      This way we can always use *param->length to get the length of data
+    */
+    if (!param->length) param->length = &param->buffer_length;
+  }
+  /* We have to send/resend type information to MySQL */
+  stmt->send_types_to_server = true;
+  stmt->bind_param_done = true;
+  DBUG_RETURN(0);
+}
+
+/********************************************************************
+ Long data implementation
+*********************************************************************/
+
+/*
+  Send long data in pieces to the server
+
+  SYNOPSIS
+    mysql_stmt_send_long_data()
+    stmt			Statement handler
+    param_number		Parameter number (0 - N-1)
+    data			Data to send to server
+    length			Length of data to send (may be 0)
+
+  DESCRIPTION
+    This call can be used repeatedly to send long data in pieces
+    for any string/binary placeholder. Data supplied for
+    a placeholder is saved at server side till execute, and then
+    used instead of value from MYSQL_BIND object. More precisely,
+    if long data for a parameter was supplied, MYSQL_BIND object
+    corresponding to this parameter is not sent to server. In the
+    end of execution long data states of placeholders are reset,
+    so next time values of such placeholders will be taken again
+    from MYSQL_BIND array.
+    The server does not reply to this call: if there was an error
+    in data handling (which now only can happen if server run out
+    of memory) it would be returned in reply to
+    mysql_stmt_execute().
+    You should choose type of long data carefully if you care
+    about character set conversions performed by server when the
+    statement is executed.  No conversion is performed at all for
+    MYSQL_TYPE_BLOB and other binary typecodes. For
+    MYSQL_TYPE_STRING and the rest of text placeholders data is
+    converted from client character set to character set of
+    connection. If these character sets are different, this
+    conversion may require additional memory at server, equal to
+    total size of supplied pieces.
+
+  RETURN VALUES
+    0	ok
+    1	error
+*/
+
+bool STDCALL mysql_stmt_send_long_data(MYSQL_STMT *stmt, uint param_number,
+                                       const char *data, ulong length) {
+  MYSQL_BIND *param;
+  DBUG_ENTER("mysql_stmt_send_long_data");
+  DBUG_ASSERT(stmt != 0);
+  DBUG_PRINT("enter", ("param no: %d  data: %p, length : %ld", param_number,
+                       data, length));
+
+  /*
+    We only need to check for stmt->param_count, if it's not null
+    prepare was done.
+  */
+  if (param_number >= stmt->param_count) {
+    set_stmt_error(stmt, CR_INVALID_PARAMETER_NO, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  param = stmt->params + param_number;
+  if (!IS_LONGDATA(param->buffer_type)) {
+    /* Long data handling should be used only for string/binary types */
+    my_stpcpy(stmt->sqlstate, unknown_sqlstate);
+    sprintf(stmt->last_error,
+            ER_CLIENT(stmt->last_errno = CR_INVALID_BUFFER_USE),
+            param->param_number);
+    DBUG_RETURN(1);
+  }
+
+  /*
+    Send long data packet if there is data or we're sending long data
+    for the first time.
+  */
+  if (length || param->long_data_used == 0) {
+    MYSQL *mysql = stmt->mysql;
+    /* Packet header: stmt id (4 bytes), param no (2 bytes) */
+    uchar buff[MYSQL_LONG_DATA_HEADER];
+
+    int4store(buff, stmt->stmt_id);
+    int2store(buff + 4, param_number);
+    param->long_data_used = 1;
+
+    /*
+      Note that we don't get any ok packet from the server in this case
+      This is intentional to save bandwidth.
+    */
+    if ((*mysql->methods->advanced_command)(
+            mysql, COM_STMT_SEND_LONG_DATA, buff, sizeof(buff),
+            pointer_cast<const uchar *>(data), length, 1, stmt)) {
+      /*
+        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, &mysql->net);
+      DBUG_RETURN(1);
+    }
+  }
+  DBUG_RETURN(0);
+}
+
+/********************************************************************
+ Fetch and conversion of result set rows (binary protocol).
+*********************************************************************/
+
+/*
+  Read date, (time, datetime) value from network buffer and store it
+  in MYSQL_TIME structure.
+
+  SYNOPSIS
+    read_binary_{date,time,datetime}()
+    tm    MYSQL_TIME structure to fill
+    pos   pointer to current position in network buffer.
+          These functions increase pos to point to the beginning of the
+          next column.
+
+  Auxiliary functions to read time (date, datetime) values from network
+  buffer and store in MYSQL_TIME structure. Jointly used by conversion
+  and no-conversion fetching.
+*/
+
+static void read_binary_time(MYSQL_TIME *tm, uchar **pos) {
+  /* net_field_length will set pos to the first byte of data */
+  uint length = net_field_length(pos);
+
+  if (length) {
+    uchar *to = *pos;
+    tm->neg = to[0];
+
+    tm->day = (ulong)sint4korr(to + 1);
+    tm->hour = (uint)to[5];
+    tm->minute = (uint)to[6];
+    tm->second = (uint)to[7];
+    tm->second_part = (length > 8) ? (ulong)sint4korr(to + 8) : 0;
+    tm->year = tm->month = 0;
+    if (tm->day) {
+      /* Convert days to hours at once */
+      tm->hour += tm->day * 24;
+      tm->day = 0;
+    }
+    tm->time_type = MYSQL_TIMESTAMP_TIME;
+
+    *pos += length;
+  } else
+    set_zero_time(tm, MYSQL_TIMESTAMP_TIME);
+}
+
+static void read_binary_datetime(MYSQL_TIME *tm, uchar **pos) {
+  uint length = net_field_length(pos);
+
+  if (length) {
+    uchar *to = *pos;
+
+    tm->neg = 0;
+    tm->year = (uint)sint2korr(to);
+    tm->month = (uint)to[2];
+    tm->day = (uint)to[3];
+
+    if (length > 4) {
+      tm->hour = (uint)to[4];
+      tm->minute = (uint)to[5];
+      tm->second = (uint)to[6];
+    } else
+      tm->hour = tm->minute = tm->second = 0;
+    tm->second_part = (length > 7) ? (ulong)sint4korr(to + 7) : 0;
+    tm->time_type = MYSQL_TIMESTAMP_DATETIME;
+
+    *pos += length;
+  } else
+    set_zero_time(tm, MYSQL_TIMESTAMP_DATETIME);
+}
+
+static void read_binary_date(MYSQL_TIME *tm, uchar **pos) {
+  uint length = net_field_length(pos);
+
+  if (length) {
+    uchar *to = *pos;
+    tm->year = (uint)sint2korr(to);
+    tm->month = (uint)to[2];
+    tm->day = (uint)to[3];
+
+    tm->hour = tm->minute = tm->second = 0;
+    tm->second_part = 0;
+    tm->neg = 0;
+    tm->time_type = MYSQL_TIMESTAMP_DATE;
+
+    *pos += length;
+  } else
+    set_zero_time(tm, MYSQL_TIMESTAMP_DATE);
+}
+
+/*
+  Convert string to supplied buffer of any type.
+
+  SYNOPSIS
+    fetch_string_with_conversion()
+    param   output buffer descriptor
+    value   column data
+    length  data length
+*/
+
+static void fetch_string_with_conversion(MYSQL_BIND *param, char *value,
+                                         size_t length) {
+  uchar *buffer = pointer_cast<uchar *>(param->buffer);
+  const char *endptr = value + length;
+
+  /*
+    This function should support all target buffer types: the rest
+    of conversion functions can delegate conversion to it.
+  */
+  switch (param->buffer_type) {
+    case MYSQL_TYPE_NULL: /* do nothing */
+      break;
+    case MYSQL_TYPE_TINY: {
+      int err;
+      longlong data = my_strtoll10(value, &endptr, &err);
+      *param->error = (IS_TRUNCATED(data, param->is_unsigned, INT_MIN8,
+                                    INT_MAX8, UINT_MAX8) ||
+                       err > 0);
+      *buffer = (uchar)data;
+      break;
+    }
+    case MYSQL_TYPE_SHORT: {
+      int err;
+      longlong data = my_strtoll10(value, &endptr, &err);
+      *param->error = (IS_TRUNCATED(data, param->is_unsigned, INT_MIN16,
+                                    INT_MAX16, UINT_MAX16) ||
+                       err > 0);
+      shortstore(buffer, (short)data);
+      break;
+    }
+    case MYSQL_TYPE_LONG: {
+      int err;
+      longlong data = my_strtoll10(value, &endptr, &err);
+      *param->error = (IS_TRUNCATED(data, param->is_unsigned, INT_MIN32,
+                                    INT_MAX32, UINT_MAX32) ||
+                       err > 0);
+      longstore(buffer, (int32)data);
+      break;
+    }
+    case MYSQL_TYPE_LONGLONG: {
+      int err;
+      longlong data = my_strtoll10(value, &endptr, &err);
+      *param->error =
+          param->is_unsigned ? err != 0 : (err > 0 || (err == 0 && data < 0));
+      longlongstore(buffer, data);
+      break;
+    }
+    case MYSQL_TYPE_FLOAT: {
+      int err;
+      double data =
+          my_strntod(&my_charset_latin1, value, length, &endptr, &err);
+      float fdata = (float)data;
+      *param->error = (fdata != data) | MY_TEST(err);
+      floatstore(buffer, fdata);
+      break;
+    }
+    case MYSQL_TYPE_DOUBLE: {
+      int err;
+      double data =
+          my_strntod(&my_charset_latin1, value, length, &endptr, &err);
+      *param->error = MY_TEST(err);
+      doublestore(buffer, data);
+      break;
+    }
+    case MYSQL_TYPE_TIME: {
+      MYSQL_TIME_STATUS status;
+      MYSQL_TIME *tm = (MYSQL_TIME *)buffer;
+      str_to_time(value, length, tm, &status);
+      *param->error = MY_TEST(status.warnings);
+      break;
+    }
+    case MYSQL_TYPE_DATE:
+    case MYSQL_TYPE_DATETIME:
+    case MYSQL_TYPE_TIMESTAMP: {
+      MYSQL_TIME_STATUS status;
+      MYSQL_TIME *tm = (MYSQL_TIME *)buffer;
+      (void)str_to_datetime(value, length, tm, TIME_FUZZY_DATE, &status);
+      *param->error =
+          MY_TEST(status.warnings) && (param->buffer_type == MYSQL_TYPE_DATE &&
+                                       tm->time_type != MYSQL_TIMESTAMP_DATE);
+      break;
+    }
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB:
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_DECIMAL:
+    case MYSQL_TYPE_NEWDECIMAL:
+    default: {
+      /*
+        Copy column data to the buffer taking into account offset,
+        data length and buffer length.
+      */
+      char *start = value + param->offset;
+      char *end = value + length;
+      size_t copy_length;
+      if (start < end) {
+        copy_length = end - start;
+        /* We've got some data beyond offset: copy up to buffer_length bytes */
+        if (param->buffer_length)
+          memcpy(buffer, start, MY_MIN(copy_length, param->buffer_length));
+      } else
+        copy_length = 0;
+      if (copy_length < param->buffer_length) buffer[copy_length] = '\0';
+      *param->error = copy_length > param->buffer_length;
+      /*
+        param->length will always contain length of entire column;
+        number of copied bytes may be way different:
+      */
+      *param->length = (unsigned long)length;
+      break;
+    }
+  }
+}
+
+/*
+  Convert integer value to client buffer of any type.
+
+  SYNOPSIS
+    fetch_long_with_conversion()
+    param   output buffer descriptor
+    field   column metadata
+    value   column data
+*/
+
+static void fetch_long_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field,
+                                       longlong value, bool is_unsigned) {
+  uchar *buffer = pointer_cast<uchar *>(param->buffer);
+
+  switch (param->buffer_type) {
+    case MYSQL_TYPE_NULL: /* do nothing */
+      break;
+    case MYSQL_TYPE_TINY:
+      *param->error = IS_TRUNCATED(value, param->is_unsigned, INT_MIN8,
+                                   INT_MAX8, UINT_MAX8);
+      *(uchar *)param->buffer = (uchar)value;
+      break;
+    case MYSQL_TYPE_SHORT:
+      *param->error = IS_TRUNCATED(value, param->is_unsigned, INT_MIN16,
+                                   INT_MAX16, UINT_MAX16);
+      shortstore(buffer, (short)value);
+      break;
+    case MYSQL_TYPE_LONG:
+      *param->error = IS_TRUNCATED(value, param->is_unsigned, INT_MIN32,
+                                   INT_MAX32, UINT_MAX32);
+      longstore(buffer, (int32)value);
+      break;
+    case MYSQL_TYPE_LONGLONG:
+      longlongstore(buffer, value);
+      *param->error = param->is_unsigned != is_unsigned && value < 0;
+      break;
+    case MYSQL_TYPE_FLOAT: {
+      /*
+        We need to mark the local variable volatile to
+        workaround Intel FPU executive precision feature.
+        (See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 for details)
+      */
+      volatile float data;
+      if (is_unsigned) {
+        data = (float)ulonglong2double(value);
+        *param->error = ((ulonglong)value) != ((ulonglong)data);
+      } else {
+        data = (float)value;
+        *param->error = value != ((longlong)data);
+      }
+      floatstore(buffer, data);
+      break;
+    }
+    case MYSQL_TYPE_DOUBLE: {
+      volatile double data;
+      if (is_unsigned) {
+        data = ulonglong2double(value);
+        *param->error =
+            data >= ULLONG_MAX || ((ulonglong)value) != ((ulonglong)data);
+      } else {
+        data = (double)value;
+        *param->error = value != ((longlong)data);
+      }
+      doublestore(buffer, data);
+      break;
+    }
+    case MYSQL_TYPE_TIME:
+    case MYSQL_TYPE_DATE:
+    case MYSQL_TYPE_TIMESTAMP:
+    case MYSQL_TYPE_DATETIME: {
+      int error;
+      value = number_to_datetime(value, (MYSQL_TIME *)buffer, TIME_FUZZY_DATE,
+                                 &error);
+      *param->error = MY_TEST(error);
+      break;
+    }
+    default: {
+      uchar buff[22]; /* Enough for longlong */
+      uchar *end = (uchar *)longlong10_to_str(value, (char *)buff,
+                                              is_unsigned ? 10 : -10);
+      /* Resort to string conversion which supports all typecodes */
+      uint length = (uint)(end - buff);
+
+      if (field->flags & ZEROFILL_FLAG && length < field->length &&
+          field->length < 21) {
+        memmove(buff + field->length - length, buff, length);
+        memset(buff, '0', field->length - length);
+        length = field->length;
+      }
+      fetch_string_with_conversion(param, (char *)buff, length);
+      break;
+    }
+  }
+}
+
+/*
+  Convert double/float column to supplied buffer of any type.
+
+  SYNOPSIS
+    fetch_float_with_conversion()
+    param   output buffer descriptor
+    field   column metadata
+    value   column data
+    type    either MY_GCVT_ARG_FLOAT or MY_GCVT_ARG_DOUBLE.
+            Affects the maximum number of significant digits
+            returned by my_gcvt().
+*/
+
+static void fetch_float_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field,
+                                        double value, my_gcvt_arg_type type) {
+  uchar *buffer = pointer_cast<uchar *>(param->buffer);
+  double val64 = (value < 0 ? -floor(-value) : floor(value));
+
+  switch (param->buffer_type) {
+    case MYSQL_TYPE_NULL: /* do nothing */
+      break;
+    case MYSQL_TYPE_TINY:
+      /*
+        We need to _store_ data in the buffer before the truncation check to
+        workaround Intel FPU executive precision feature.
+        (See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=323 for details)
+        Sic: AFAIU it does not guarantee to work.
+      */
+      if (param->is_unsigned) {
+        if (value < 0.0) {
+          *param->error = true;
+          break;
+        }
+        *buffer = (uint8)value;
+      } else {
+        *buffer = (int8)value;
+      }
+      *param->error = val64 != (param->is_unsigned ? (double)((uint8)*buffer)
+                                                   : (double)((int8)*buffer));
+      break;
+    case MYSQL_TYPE_SHORT:
+      if (param->is_unsigned) {
+        if (value < 0.0) {
+          *param->error = true;
+          break;
+        }
+        ushort data = (ushort)value;
+        shortstore(buffer, data);
+      } else {
+        short data = (short)value;
+        shortstore(buffer, data);
+      }
+      *param->error =
+          val64 != (param->is_unsigned ? (double)(*(ushort *)buffer)
+                                       : (double)(*(short *)buffer));
+      break;
+    case MYSQL_TYPE_LONG:
+      if (param->is_unsigned) {
+        if (value < 0.0) {
+          *param->error = true;
+          break;
+        }
+        uint32 data = (uint32)value;
+        longstore(buffer, data);
+      } else {
+        int32 data = (int32)value;
+        longstore(buffer, data);
+      }
+      *param->error =
+          val64 != (param->is_unsigned ? (double)(*(uint32 *)buffer)
+                                       : (double)(*(int32 *)buffer));
+      break;
+    case MYSQL_TYPE_LONGLONG:
+      if (param->is_unsigned) {
+        if (value < 0.0) {
+          *param->error = true;
+          break;
+        }
+        ulonglong data = (ulonglong)value;
+        longlongstore(buffer, data);
+      } else {
+        longlong data = (longlong)value;
+        longlongstore(buffer, data);
+      }
+      *param->error =
+          val64 != (param->is_unsigned ? ulonglong2double(*(ulonglong *)buffer)
+                                       : (double)(*(longlong *)buffer));
+      break;
+    case MYSQL_TYPE_FLOAT: {
+      float data = (float)value;
+      floatstore(buffer, data);
+      *param->error = (*(float *)buffer) != value;
+      break;
+    }
+    case MYSQL_TYPE_DOUBLE: {
+      doublestore(buffer, value);
+      break;
+    }
+    default: {
+      /*
+        Resort to fetch_string_with_conversion: this should handle
+        floating point -> string conversion nicely, honor all typecodes
+        and param->offset possibly set in mysql_stmt_fetch_column
+      */
+      char buff[FLOATING_POINT_BUFFER];
+      size_t len;
+      if (field->decimals >= NOT_FIXED_DEC)
+        len = my_gcvt(value, type,
+                      (int)MY_MIN(sizeof(buff) - 1, param->buffer_length), buff,
+                      NULL);
+      else
+        len = my_fcvt(value, (int)field->decimals, buff, NULL);
+
+      if (field->flags & ZEROFILL_FLAG && len < field->length &&
+          field->length < MAX_DOUBLE_STRING_REP_LENGTH - 1) {
+        memmove(buff + field->length - len, buff, len);
+        memset(buff, '0', field->length - len);
+        len = field->length;
+      }
+      fetch_string_with_conversion(param, buff, len);
+
+      break;
+    }
+  }
+}
+
+/*
+  Fetch time/date/datetime to supplied buffer of any type
+
+  SYNOPSIS
+    param   output buffer descriptor
+    time    column data
+*/
+
+static void fetch_datetime_with_conversion(MYSQL_BIND *param,
+                                           MYSQL_FIELD *field,
+                                           MYSQL_TIME *my_time) {
+  switch (param->buffer_type) {
+    case MYSQL_TYPE_NULL: /* do nothing */
+      break;
+    case MYSQL_TYPE_DATE:
+      *(MYSQL_TIME *)(param->buffer) = *my_time;
+      *param->error = my_time->time_type != MYSQL_TIMESTAMP_DATE;
+      break;
+    case MYSQL_TYPE_TIME:
+      *(MYSQL_TIME *)(param->buffer) = *my_time;
+      *param->error = my_time->time_type != MYSQL_TIMESTAMP_TIME;
+      break;
+    case MYSQL_TYPE_DATETIME:
+    case MYSQL_TYPE_TIMESTAMP:
+      *(MYSQL_TIME *)(param->buffer) = *my_time;
+      /* No error: time and date are compatible with datetime */
+      break;
+    case MYSQL_TYPE_YEAR:
+      shortstore(pointer_cast<uchar *>(param->buffer), my_time->year);
+      *param->error = 1;
+      break;
+    case MYSQL_TYPE_FLOAT:
+    case MYSQL_TYPE_DOUBLE: {
+      ulonglong value = TIME_to_ulonglong(*my_time);
+      fetch_float_with_conversion(param, field, ulonglong2double(value),
+                                  MY_GCVT_ARG_DOUBLE);
+      break;
+    }
+    case MYSQL_TYPE_TINY:
+    case MYSQL_TYPE_SHORT:
+    case MYSQL_TYPE_INT24:
+    case MYSQL_TYPE_LONG:
+    case MYSQL_TYPE_LONGLONG: {
+      longlong value = (longlong)TIME_to_ulonglong(*my_time);
+      fetch_long_with_conversion(param, field, value, true);
+      break;
+    }
+    default: {
+      /*
+        Convert time value  to string and delegate the rest to
+        fetch_string_with_conversion:
+      */
+      char buff[MAX_DATE_STRING_REP_LENGTH];
+      uint length = my_TIME_to_str(*my_time, buff, field->decimals);
+      /* Resort to string conversion */
+      fetch_string_with_conversion(param, (char *)buff, length);
+      break;
+    }
+  }
+}
+
+/*
+  Fetch and convert result set column to output buffer.
+
+  SYNOPSIS
+    fetch_result_with_conversion()
+    param   output buffer descriptor
+    field   column metadata
+    row     points to a column of result set tuple in binary format
+
+  DESCRIPTION
+    This is a fallback implementation of column fetch used
+    if column and output buffer types do not match.
+    Increases tuple pointer to point at the next column within the
+    tuple.
+*/
+
+static void fetch_result_with_conversion(MYSQL_BIND *param, MYSQL_FIELD *field,
+                                         uchar **row) {
+  enum enum_field_types field_type = field->type;
+  uint field_is_unsigned = field->flags & UNSIGNED_FLAG;
+
+  switch (field_type) {
+    case MYSQL_TYPE_TINY: {
+      uchar value = **row;
+      /* sic: we need to cast to 'signed char' as 'char' may be unsigned */
+      longlong data =
+          field_is_unsigned ? (longlong)value : (longlong)(signed char)value;
+      fetch_long_with_conversion(param, field, data, 0);
+      *row += 1;
+      break;
+    }
+    case MYSQL_TYPE_SHORT:
+    case MYSQL_TYPE_YEAR: {
+      short value = sint2korr(*row);
+      longlong data =
+          field_is_unsigned ? (longlong)(unsigned short)value : (longlong)value;
+      fetch_long_with_conversion(param, field, data, 0);
+      *row += 2;
+      break;
+    }
+    case MYSQL_TYPE_INT24: /* mediumint is sent as 4 bytes int */
+    case MYSQL_TYPE_LONG: {
+      int32 value = sint4korr(*row);
+      longlong data =
+          field_is_unsigned ? (longlong)(uint32)value : (longlong)value;
+      fetch_long_with_conversion(param, field, data, 0);
+      *row += 4;
+      break;
+    }
+    case MYSQL_TYPE_LONGLONG: {
+      longlong value = (longlong)sint8korr(*row);
+      fetch_long_with_conversion(param, field, value,
+                                 field->flags & UNSIGNED_FLAG);
+      *row += 8;
+      break;
+    }
+    case MYSQL_TYPE_FLOAT: {
+      float value;
+      float4get(&value, *row);
+      fetch_float_with_conversion(param, field, value, MY_GCVT_ARG_FLOAT);
+      *row += 4;
+      break;
+    }
+    case MYSQL_TYPE_DOUBLE: {
+      double value;
+      float8get(&value, *row);
+      fetch_float_with_conversion(param, field, value, MY_GCVT_ARG_DOUBLE);
+      *row += 8;
+      break;
+    }
+    case MYSQL_TYPE_DATE: {
+      MYSQL_TIME tm;
+
+      read_binary_date(&tm, row);
+      fetch_datetime_with_conversion(param, field, &tm);
+      break;
+    }
+    case MYSQL_TYPE_TIME: {
+      MYSQL_TIME tm;
+
+      read_binary_time(&tm, row);
+      fetch_datetime_with_conversion(param, field, &tm);
+      break;
+    }
+    case MYSQL_TYPE_DATETIME:
+    case MYSQL_TYPE_TIMESTAMP: {
+      MYSQL_TIME tm;
+
+      read_binary_datetime(&tm, row);
+      fetch_datetime_with_conversion(param, field, &tm);
+      break;
+    }
+    default: {
+      ulong length = net_field_length(row);
+      fetch_string_with_conversion(param, (char *)*row, length);
+      *row += length;
+      break;
+    }
+  }
+}
+
+/*
+  Functions to fetch data to application buffers without conversion.
+
+  All functions have the following characteristics:
+
+  SYNOPSIS
+    fetch_result_xxx()
+    param   MySQL bind param
+    pos     Row value
+
+  DESCRIPTION
+    These are no-conversion functions, used in binary protocol to store
+    rows in application buffers. A function used only if type of binary data
+    is compatible with type of application buffer.
+
+  RETURN
+    none
+*/
+
+static void fetch_result_tinyint(MYSQL_BIND *param, MYSQL_FIELD *field,
+                                 uchar **row) {
+  bool field_is_unsigned = (field->flags & UNSIGNED_FLAG);
+  uchar data = **row;
+  *(uchar *)param->buffer = data;
+  *param->error = param->is_unsigned != field_is_unsigned && data > INT_MAX8;
+  (*row)++;
+}
+
+static void fetch_result_short(MYSQL_BIND *param, MYSQL_FIELD *field,
+                               uchar **row) {
+  bool field_is_unsigned = (field->flags & UNSIGNED_FLAG);
+  ushort data = (ushort)sint2korr(*row);
+  shortstore(pointer_cast<uchar *>(param->buffer), data);
+  *param->error = param->is_unsigned != field_is_unsigned && data > INT_MAX16;
+  *row += 2;
+}
+
+static void fetch_result_int32(MYSQL_BIND *param,
+                               MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                               uchar **row) {
+  bool field_is_unsigned = (field->flags & UNSIGNED_FLAG);
+  uint32 data = (uint32)sint4korr(*row);
+  longstore(pointer_cast<uchar *>(param->buffer), data);
+  *param->error = param->is_unsigned != field_is_unsigned && data > INT_MAX32;
+  *row += 4;
+}
+
+static void fetch_result_int64(MYSQL_BIND *param,
+                               MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                               uchar **row) {
+  bool field_is_unsigned = (field->flags & UNSIGNED_FLAG);
+  ulonglong data = (ulonglong)sint8korr(*row);
+  *param->error = param->is_unsigned != field_is_unsigned && data > LLONG_MAX;
+  longlongstore(pointer_cast<uchar *>(param->buffer), data);
+  *row += 8;
+}
+
+static void fetch_result_float(MYSQL_BIND *param,
+                               MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                               uchar **row) {
+  float value;
+  float4get(&value, *row);
+  floatstore(pointer_cast<uchar *>(param->buffer), value);
+  *row += 4;
+}
+
+static void fetch_result_double(MYSQL_BIND *param,
+                                MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                                uchar **row) {
+  double value;
+  float8get(&value, *row);
+  doublestore(pointer_cast<uchar *>(param->buffer), value);
+  *row += 8;
+}
+
+static void fetch_result_time(MYSQL_BIND *param,
+                              MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                              uchar **row) {
+  MYSQL_TIME *tm = (MYSQL_TIME *)param->buffer;
+  read_binary_time(tm, row);
+}
+
+static void fetch_result_date(MYSQL_BIND *param,
+                              MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                              uchar **row) {
+  MYSQL_TIME *tm = (MYSQL_TIME *)param->buffer;
+  read_binary_date(tm, row);
+}
+
+static void fetch_result_datetime(MYSQL_BIND *param,
+                                  MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                                  uchar **row) {
+  MYSQL_TIME *tm = (MYSQL_TIME *)param->buffer;
+  read_binary_datetime(tm, row);
+}
+
+static void fetch_result_bin(MYSQL_BIND *param,
+                             MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                             uchar **row) {
+  ulong length = net_field_length(row);
+  ulong copy_length = MY_MIN(length, param->buffer_length);
+  memcpy(param->buffer, (char *)*row, copy_length);
+  *param->length = length;
+  *param->error = copy_length < length;
+  *row += length;
+}
+
+static void fetch_result_str(MYSQL_BIND *param,
+                             MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                             uchar **row) {
+  ulong length = net_field_length(row);
+  ulong copy_length = MY_MIN(length, param->buffer_length);
+  memcpy(param->buffer, (char *)*row, copy_length);
+  /* Add an end null if there is room in the buffer */
+  if (copy_length != param->buffer_length)
+    ((uchar *)param->buffer)[copy_length] = '\0';
+  *param->length = length; /* return total length */
+  *param->error = copy_length < length;
+  *row += length;
+}
+
+/*
+  functions to calculate max lengths for strings during
+  mysql_stmt_store_result()
+*/
+
+static void skip_result_fixed(MYSQL_BIND *param,
+                              MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                              uchar **row)
+
+{
+  (*row) += param->pack_length;
+}
+
+static void skip_result_with_length(MYSQL_BIND *param MY_ATTRIBUTE((unused)),
+                                    MYSQL_FIELD *field MY_ATTRIBUTE((unused)),
+                                    uchar **row)
+
+{
+  ulong length = net_field_length(row);
+  (*row) += length;
+}
+
+static void skip_result_string(MYSQL_BIND *param MY_ATTRIBUTE((unused)),
+                               MYSQL_FIELD *field, uchar **row)
+
+{
+  ulong length = net_field_length(row);
+  (*row) += length;
+  if (field->max_length < length) field->max_length = length;
+}
+
+/*
+  Check that two field types are binary compatible i. e.
+  have equal representation in the binary protocol and
+  require client-side buffers of the same type.
+
+  SYNOPSIS
+    is_binary_compatible()
+    type1   parameter type supplied by user
+    type2   field type, obtained from result set metadata
+
+  RETURN
+    true or false
+*/
+
+static bool is_binary_compatible(enum enum_field_types type1,
+                                 enum enum_field_types type2) {
+  static const enum enum_field_types
+      range1[] = {MYSQL_TYPE_SHORT, MYSQL_TYPE_YEAR, MYSQL_TYPE_NULL},
+      range2[] = {MYSQL_TYPE_INT24, MYSQL_TYPE_LONG, MYSQL_TYPE_NULL},
+      range3[] = {MYSQL_TYPE_DATETIME, MYSQL_TYPE_TIMESTAMP, MYSQL_TYPE_NULL},
+      range4[] = {
+          MYSQL_TYPE_ENUM,        MYSQL_TYPE_SET,       MYSQL_TYPE_TINY_BLOB,
+          MYSQL_TYPE_MEDIUM_BLOB, MYSQL_TYPE_LONG_BLOB, MYSQL_TYPE_BLOB,
+          MYSQL_TYPE_VAR_STRING,  MYSQL_TYPE_STRING,    MYSQL_TYPE_GEOMETRY,
+          MYSQL_TYPE_DECIMAL,     MYSQL_TYPE_NULL};
+  static const enum enum_field_types *range_list[] = {range1, range2, range3,
+                                                      range4},
+                                     **range_list_end =
+                                         range_list + sizeof(range_list) /
+                                                          sizeof(*range_list);
+  const enum enum_field_types **range, *type;
+
+  if (type1 == type2) return true;
+  for (range = range_list; range != range_list_end; ++range) {
+    /* check that both type1 and type2 are in the same range */
+    bool type1_found = false, type2_found = false;
+    for (type = *range; *type != MYSQL_TYPE_NULL; type++) {
+      type1_found |= type1 == *type;
+      type2_found |= type2 == *type;
+    }
+    if (type1_found || type2_found) return type1_found && type2_found;
+  }
+  return false;
+}
+
+/*
+  Setup a fetch function for one column of a result set.
+
+  SYNOPSIS
+    setup_one_fetch_function()
+    param    output buffer descriptor
+    field    column descriptor
+
+  DESCRIPTION
+    When user binds result set buffers or when result set
+    metadata is changed, we need to setup fetch (and possibly
+    conversion) functions for all columns of the result set.
+    In addition to that here we set up skip_result function, used
+    to update result set metadata in case when
+    STMT_ATTR_UPDATE_MAX_LENGTH attribute is set.
+    Notice that while fetch_result is chosen depending on both
+    field->type and param->type, skip_result depends on field->type
+    only.
+
+  RETURN
+    true   fetch function for this typecode was not found (typecode
+          is not supported by the client library)
+    false  success
+*/
+
+static bool setup_one_fetch_function(MYSQL_BIND *param, MYSQL_FIELD *field) {
+  DBUG_ENTER("setup_one_fetch_function");
+
+  /* Setup data copy functions for the different supported types */
+  switch (param->buffer_type) {
+    case MYSQL_TYPE_NULL: /* for dummy binds */
+      /*
+        It's not binary compatible with anything the server can return:
+        no need to setup fetch_result, as it'll be reset anyway
+      */
+      *param->length = 0;
+      break;
+    case MYSQL_TYPE_TINY:
+      param->fetch_result = fetch_result_tinyint;
+      *param->length = 1;
+      break;
+    case MYSQL_TYPE_SHORT:
+    case MYSQL_TYPE_YEAR:
+      param->fetch_result = fetch_result_short;
+      *param->length = 2;
+      break;
+    case MYSQL_TYPE_INT24:
+    case MYSQL_TYPE_LONG:
+      param->fetch_result = fetch_result_int32;
+      *param->length = 4;
+      break;
+    case MYSQL_TYPE_LONGLONG:
+      param->fetch_result = fetch_result_int64;
+      *param->length = 8;
+      break;
+    case MYSQL_TYPE_FLOAT:
+      param->fetch_result = fetch_result_float;
+      *param->length = 4;
+      break;
+    case MYSQL_TYPE_DOUBLE:
+      param->fetch_result = fetch_result_double;
+      *param->length = 8;
+      break;
+    case MYSQL_TYPE_TIME:
+      param->fetch_result = fetch_result_time;
+      *param->length = sizeof(MYSQL_TIME);
+      break;
+    case MYSQL_TYPE_DATE:
+      param->fetch_result = fetch_result_date;
+      *param->length = sizeof(MYSQL_TIME);
+      break;
+    case MYSQL_TYPE_DATETIME:
+    case MYSQL_TYPE_TIMESTAMP:
+      param->fetch_result = fetch_result_datetime;
+      *param->length = sizeof(MYSQL_TIME);
+      break;
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB:
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_BIT:
+      DBUG_ASSERT(param->buffer_length != 0);
+      param->fetch_result = fetch_result_bin;
+      break;
+    case MYSQL_TYPE_VAR_STRING:
+    case MYSQL_TYPE_STRING:
+    case MYSQL_TYPE_DECIMAL:
+    case MYSQL_TYPE_NEWDECIMAL:
+    case MYSQL_TYPE_NEWDATE:
+    case MYSQL_TYPE_JSON:
+      DBUG_ASSERT(param->buffer_length != 0);
+      param->fetch_result = fetch_result_str;
+      break;
+    default:
+      DBUG_PRINT("error",
+                 ("Unknown param->buffer_type: %u", (uint)param->buffer_type));
+      DBUG_RETURN(true);
+  }
+  if (!is_binary_compatible(param->buffer_type, field->type))
+    param->fetch_result = fetch_result_with_conversion;
+
+  /* Setup skip_result functions (to calculate max_length) */
+  param->skip_result = skip_result_fixed;
+  switch (field->type) {
+    case MYSQL_TYPE_NULL: /* for dummy binds */
+      param->pack_length = 0;
+      field->max_length = 0;
+      break;
+    case MYSQL_TYPE_TINY:
+      param->pack_length = 1;
+      field->max_length = 4; /* as in '-127' */
+      break;
+    case MYSQL_TYPE_YEAR:
+    case MYSQL_TYPE_SHORT:
+      param->pack_length = 2;
+      field->max_length = 6; /* as in '-32767' */
+      break;
+    case MYSQL_TYPE_INT24:
+      field->max_length = 9; /* as in '16777216' or in '-8388607' */
+      param->pack_length = 4;
+      break;
+    case MYSQL_TYPE_LONG:
+      field->max_length = 11; /* '-2147483647' */
+      param->pack_length = 4;
+      break;
+    case MYSQL_TYPE_LONGLONG:
+      field->max_length = 21; /* '18446744073709551616' */
+      param->pack_length = 8;
+      break;
+    case MYSQL_TYPE_FLOAT:
+      param->pack_length = 4;
+      field->max_length = MAX_DOUBLE_STRING_REP_LENGTH;
+      break;
+    case MYSQL_TYPE_DOUBLE:
+      param->pack_length = 8;
+      field->max_length = MAX_DOUBLE_STRING_REP_LENGTH;
+      break;
+    case MYSQL_TYPE_TIME:
+      field->max_length = 17; /* -819:23:48.123456 */
+      param->skip_result = skip_result_with_length;
+      break;
+    case MYSQL_TYPE_DATE:
+      field->max_length = 10; /* 2003-11-11 */
+      param->skip_result = skip_result_with_length;
+      break;
+    case MYSQL_TYPE_DATETIME:
+    case MYSQL_TYPE_TIMESTAMP:
+      param->skip_result = skip_result_with_length;
+      field->max_length = MAX_DATE_STRING_REP_LENGTH;
+      break;
+    case MYSQL_TYPE_DECIMAL:
+    case MYSQL_TYPE_NEWDECIMAL:
+    case MYSQL_TYPE_ENUM:
+    case MYSQL_TYPE_SET:
+    case MYSQL_TYPE_GEOMETRY:
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB:
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_VAR_STRING:
+    case MYSQL_TYPE_STRING:
+    case MYSQL_TYPE_BIT:
+    case MYSQL_TYPE_NEWDATE:
+    case MYSQL_TYPE_JSON:
+      param->skip_result = skip_result_string;
+      break;
+    default:
+      DBUG_PRINT("error", ("Unknown field->type: %u", (uint)field->type));
+      DBUG_RETURN(true);
+  }
+  DBUG_RETURN(false);
+}
+
+/*
+  Setup the bind buffers for resultset processing
+*/
+
+bool STDCALL mysql_stmt_bind_result(MYSQL_STMT *stmt, MYSQL_BIND *my_bind) {
+  MYSQL_BIND *param, *end;
+  MYSQL_FIELD *field;
+  ulong bind_count = stmt->field_count;
+  uint param_count = 0;
+  DBUG_ENTER("mysql_stmt_bind_result");
+  DBUG_PRINT("enter", ("field_count: %lu", bind_count));
+
+  if (!bind_count) {
+    int errorcode = (int)stmt->state < (int)MYSQL_STMT_PREPARE_DONE
+                        ? CR_NO_PREPARE_STMT
+                        : CR_NO_STMT_METADATA;
+    set_stmt_error(stmt, errorcode, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  /*
+    We only need to check that stmt->field_count - if it is not null
+    stmt->bind was initialized in mysql_stmt_prepare
+    stmt->bind overlaps with bind if mysql_stmt_bind_param
+    is called from mysql_stmt_store_result.
+    BEWARE of buffer overwrite ...
+  */
+
+  if (stmt->bind != my_bind)
+    memcpy((char *)stmt->bind, (char *)my_bind,
+           sizeof(MYSQL_BIND) * bind_count);
+
+  for (param = stmt->bind, end = param + bind_count, field = stmt->fields;
+       param < end; param++, field++) {
+    DBUG_PRINT("info", ("buffer_type: %u  field_type: %u",
+                        (uint)param->buffer_type, (uint)field->type));
+    /*
+      Set param->is_null to point to a dummy variable if it's not set.
+      This is to make the execute code easier
+    */
+    if (!param->is_null) param->is_null = &param->is_null_value;
+
+    if (!param->length) param->length = &param->length_value;
+
+    if (!param->error) param->error = &param->error_value;
+
+    param->param_number = param_count++;
+    param->offset = 0;
+
+    if (setup_one_fetch_function(param, field)) {
+      my_stpcpy(stmt->sqlstate, unknown_sqlstate);
+      sprintf(stmt->last_error,
+              ER_CLIENT(stmt->last_errno = CR_UNSUPPORTED_PARAM_TYPE),
+              field->type, param_count);
+      DBUG_RETURN(1);
+    }
+  }
+  stmt->bind_result_done = BIND_RESULT_DONE;
+  if (stmt->mysql->options.report_data_truncation)
+    stmt->bind_result_done |= REPORT_DATA_TRUNCATION;
+
+  DBUG_RETURN(0);
+}
+
+/*
+  Fetch row data to bind buffers
+*/
+
+static int stmt_fetch_row(MYSQL_STMT *stmt, uchar *row) {
+  MYSQL_BIND *my_bind, *end;
+  MYSQL_FIELD *field;
+  uchar *null_ptr, bit;
+  int truncation_count = 0;
+  /*
+    Precondition: if stmt->field_count is zero or row is NULL, read_row_*
+    function must return no data.
+  */
+  DBUG_ASSERT(stmt->field_count);
+  DBUG_ASSERT(row);
+
+  if (!stmt->bind_result_done) {
+    /* If output parameters were not bound we should just return success */
+    return 0;
+  }
+
+  null_ptr = row;
+  row += (stmt->field_count + 9) / 8; /* skip null bits */
+  bit = 4;                            /* first 2 bits are reserved */
+
+  /* Copy complete row to application buffers */
+  for (my_bind = stmt->bind, end = my_bind + stmt->field_count,
+      field = stmt->fields;
+       my_bind < end; my_bind++, field++) {
+    *my_bind->error = 0;
+    if (*null_ptr & bit) {
+      /*
+        We should set both row_ptr and is_null to be able to see
+        nulls in mysql_stmt_fetch_column. This is because is_null may point
+        to user data which can be overwritten between mysql_stmt_fetch and
+        mysql_stmt_fetch_column, and in this case nullness of column will be
+        lost. See mysql_stmt_fetch_column for details.
+      */
+      my_bind->row_ptr = NULL;
+      *my_bind->is_null = 1;
+    } else {
+      *my_bind->is_null = 0;
+      my_bind->row_ptr = row;
+      (*my_bind->fetch_result)(my_bind, field, &row);
+      truncation_count += *my_bind->error;
+    }
+    if (!((bit <<= 1) & 255)) {
+      bit = 1; /* To next uchar */
+      null_ptr++;
+    }
+  }
+  if (truncation_count && (stmt->bind_result_done & REPORT_DATA_TRUNCATION))
+    return MYSQL_DATA_TRUNCATED;
+  return 0;
+}
+
+int cli_unbuffered_fetch(MYSQL *mysql, char **row) {
+  ulong len = 0;
+  bool is_data_packet;
+  if (packet_error == cli_safe_read(mysql, &is_data_packet)) {
+    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+    return 1;
+  }
+
+  if (mysql->net.read_pos[0] != 0 && !is_data_packet) {
+    /* in case of new client read the OK packet */
+    if (mysql->server_capabilities & CLIENT_DEPRECATE_EOF)
+      read_ok_ex(mysql, len);
+    *row = NULL;
+    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+  } else {
+    *row = (char *)(mysql->net.read_pos + 1);
+  }
+
+  return 0;
+}
+
+/*
+  Fetch and return row data to bound buffers, if any
+*/
+
+int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt) {
+  int rc;
+  uchar *row;
+  DBUG_ENTER("mysql_stmt_fetch");
+
+  if ((rc = (*stmt->read_row_func)(stmt, &row)) ||
+      ((rc = stmt_fetch_row(stmt, row)) && rc != MYSQL_DATA_TRUNCATED)) {
+    stmt->state = MYSQL_STMT_PREPARE_DONE; /* XXX: this is buggy */
+    stmt->read_row_func = (rc == MYSQL_NO_DATA) ? stmt_read_row_no_data
+                                                : stmt_read_row_no_result_set;
+  } else {
+    /* This is to know in mysql_stmt_fetch_column that data was fetched */
+    stmt->state = MYSQL_STMT_FETCH_DONE;
+  }
+  DBUG_RETURN(rc);
+}
+
+/*
+  Fetch data for one specified column data
+
+  SYNOPSIS
+    mysql_stmt_fetch_column()
+    stmt		Prepared statement handler
+    my_bind		Where data should be placed. Should be filled in as
+                        when calling mysql_stmt_bind_result()
+    column		Column to fetch (first column is 0)
+    ulong offset	Offset in result data (to fetch blob in pieces)
+                        This is normally 0
+  RETURN
+    0	ok
+    1	error
+*/
+
+int STDCALL mysql_stmt_fetch_column(MYSQL_STMT *stmt, MYSQL_BIND *my_bind,
+                                    uint column, ulong offset) {
+  MYSQL_BIND *param = stmt->bind + column;
+  DBUG_ENTER("mysql_stmt_fetch_column");
+
+  if ((int)stmt->state < (int)MYSQL_STMT_FETCH_DONE) {
+    set_stmt_error(stmt, CR_NO_DATA, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+  if (column >= stmt->field_count) {
+    set_stmt_error(stmt, CR_INVALID_PARAMETER_NO, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  if (!my_bind->error) my_bind->error = &my_bind->error_value;
+  *my_bind->error = 0;
+  if (param->row_ptr) {
+    MYSQL_FIELD *field = stmt->fields + column;
+    uchar *row = param->row_ptr;
+    my_bind->offset = offset;
+    if (my_bind->is_null) *my_bind->is_null = 0;
+    if (my_bind->length) /* Set the length if non char/binary types */
+      *my_bind->length = *param->length;
+    else
+      my_bind->length = &param->length_value; /* Needed for fetch_result() */
+    fetch_result_with_conversion(my_bind, field, &row);
+  } else {
+    if (my_bind->is_null) *my_bind->is_null = 1;
+  }
+  DBUG_RETURN(0);
+}
+
+/*
+  Read all rows of data from server  (binary format)
+*/
+
+int cli_read_binary_rows(MYSQL_STMT *stmt) {
+  ulong pkt_len;
+  uchar *cp;
+  MYSQL *mysql = stmt->mysql;
+  MYSQL_DATA *result = &stmt->result;
+  MYSQL_ROWS **prev_ptr = &result->data;
+  NET *net;
+  bool is_data_packet;
+
+  DBUG_ENTER("cli_read_binary_rows");
+
+  if (!mysql) {
+    set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  net = &mysql->net;
+  /*
+   We could have read one row in execute() due to the lack of a cursor,
+   but one at most.
+  */
+  DBUG_ASSERT(result->rows <= 1);
+  if (result->rows == 1) prev_ptr = &result->data->next;
+
+  while ((pkt_len = cli_safe_read(mysql, &is_data_packet)) != packet_error) {
+    cp = net->read_pos;
+    if (*cp == 0 || is_data_packet) {
+      if (add_binary_row(net, stmt, pkt_len, &prev_ptr)) goto err;
+    } else {
+      /* end of data */
+      *prev_ptr = 0;
+      /* read warning count from OK packet or EOF packet if it is old client */
+      if (mysql->server_capabilities & CLIENT_DEPRECATE_EOF && !is_data_packet)
+        read_ok_ex(mysql, pkt_len);
+      else
+        mysql->warning_count = uint2korr(cp + 1);
+      /*
+        OUT parameters result sets has SERVER_PS_OUT_PARAMS and
+        SERVER_MORE_RESULTS_EXISTS flags in first EOF_Packet only.
+        Last EOF_Packet of OUT parameters result sets have no
+        SERVER_MORE_RESULTS_EXISTS flag as described here:
+        http://dev.mysql.com/doc/internals/en/stored-procedures.html#out-parameter-set
+        Following code reads last EOF_Packet of result set and can clear
+        those flags in server_status if we don't preserve them.
+        Without SERVER_MORE_RESULTS_EXISTS flag mysql_stmt_next_result fails
+        to read OK_Packet after OUT parameters result set.
+        So we need to preserve SERVER_MORE_RESULTS_EXISTS flag for OUT
+        parameters result set.
+      */
+      if (mysql->server_status & SERVER_PS_OUT_PARAMS) {
+        mysql->server_status =
+            uint2korr(cp + 3) | SERVER_PS_OUT_PARAMS |
+            (mysql->server_status & SERVER_MORE_RESULTS_EXISTS);
+      } else
+        mysql->server_status = uint2korr(cp + 3);
+      DBUG_PRINT("info", ("status: %u  warning_count: %u", mysql->server_status,
+                          mysql->warning_count));
+#if defined(CLIENT_PROTOCOL_TRACING)
+      if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
+        MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
+      else
+        MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+#endif
+      DBUG_RETURN(0);
+    }
+  }
+  set_stmt_errmsg(stmt, net);
+
+err:
+  DBUG_RETURN(1);
+}
+
+/*
+  Update meta data for statement
+
+  SYNOPSIS
+    stmt_update_metadata()
+    stmt			Statement handler
+    row				Binary data
+
+  NOTES
+    Only updates MYSQL_FIELD->max_length for strings
+*/
+
+static void stmt_update_metadata(MYSQL_STMT *stmt, MYSQL_ROWS *data) {
+  MYSQL_BIND *my_bind, *end;
+  MYSQL_FIELD *field;
+  uchar *null_ptr, bit;
+  uchar *row = (uchar *)data->data;
+#ifndef DBUG_OFF
+  uchar *row_end = row + data->length;
+#endif
+
+  null_ptr = row;
+  row += (stmt->field_count + 9) / 8; /* skip null bits */
+  bit = 4;                            /* first 2 bits are reserved */
+
+  /* Go through all fields and calculate metadata */
+  for (my_bind = stmt->bind, end = my_bind + stmt->field_count,
+      field = stmt->fields;
+       my_bind < end; my_bind++, field++) {
+    if (!(*null_ptr & bit)) (*my_bind->skip_result)(my_bind, field, &row);
+    DBUG_ASSERT(row <= row_end);
+    if (!((bit <<= 1) & 255)) {
+      bit = 1; /* To next uchar */
+      null_ptr++;
+    }
+  }
+}
+
+/*
+  Store or buffer the binary results to stmt
+*/
+
+int STDCALL mysql_stmt_store_result(MYSQL_STMT *stmt) {
+  MYSQL *mysql = stmt->mysql;
+  MYSQL_DATA *result = &stmt->result;
+  DBUG_ENTER("mysql_stmt_store_result");
+
+  if (!mysql) {
+    /* mysql can be reset in mysql_close called from mysql_reconnect */
+    set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  if (!stmt->field_count) DBUG_RETURN(0);
+
+  if ((int)stmt->state < (int)MYSQL_STMT_EXECUTE_DONE) {
+    set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  if (stmt->last_errno) {
+    /* An attempt to use an invalid statement handle. */
+    DBUG_RETURN(1);
+  }
+
+  if (mysql->status == MYSQL_STATUS_READY &&
+      stmt->server_status & SERVER_STATUS_CURSOR_EXISTS) {
+    /*
+      Server side cursor exist, tell server to start sending the rows
+    */
+    NET *net = &mysql->net;
+    uchar buff[4 /* statement id */ + 4 /* number of rows to fetch */];
+
+    /* Send row request to the server */
+    int4store(buff, stmt->stmt_id);
+    int4store(buff + 4, (int)~0); /* number of rows to fetch */
+    if (cli_advanced_command(mysql, COM_STMT_FETCH, buff, sizeof(buff),
+                             (uchar *)0, 0, 1, stmt)) {
+      /*
+        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_STATEMENT_GET_RESULT) {
+    set_stmt_error(stmt, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+
+  if (stmt->update_max_length && !stmt->bind_result_done) {
+    /*
+      We must initalize the bind structure to be able to calculate
+      max_length
+    */
+    MYSQL_BIND *my_bind, *end;
+    MYSQL_FIELD *field;
+    memset(stmt->bind, 0, sizeof(*stmt->bind) * stmt->field_count);
+
+    for (my_bind = stmt->bind, end = my_bind + stmt->field_count,
+        field = stmt->fields;
+         my_bind < end; my_bind++, field++) {
+      my_bind->buffer_type = MYSQL_TYPE_NULL;
+      my_bind->buffer_length = 1;
+    }
+
+    if (mysql_stmt_bind_result(stmt, stmt->bind)) DBUG_RETURN(1);
+    stmt->bind_result_done = 0; /* No normal bind done */
+  }
+
+  if ((*mysql->methods->read_binary_rows)(stmt)) {
+    free_root(result->alloc, MYF(MY_KEEP_PREALLOC));
+    result->data = NULL;
+    result->rows = 0;
+    mysql->status = MYSQL_STATUS_READY;
+    DBUG_RETURN(1);
+  }
+
+  /* Assert that if there was a cursor, all rows have been fetched */
+  DBUG_ASSERT(mysql->status != MYSQL_STATUS_READY ||
+              (mysql->server_status & SERVER_STATUS_LAST_ROW_SENT));
+
+  if (stmt->update_max_length) {
+    MYSQL_ROWS *cur = result->data;
+    for (; cur; cur = cur->next) stmt_update_metadata(stmt, cur);
+  }
+
+  stmt->data_cursor = result->data;
+  mysql->affected_rows = stmt->affected_rows = result->rows;
+  stmt->read_row_func = stmt_read_row_buffered;
+  mysql->unbuffered_fetch_owner = 0;  /* set in stmt_execute */
+  mysql->status = MYSQL_STATUS_READY; /* server is ready */
+  DBUG_RETURN(0); /* Data buffered, must be fetched with mysql_stmt_fetch() */
+}
+
+/*
+  Seek to desired row in the statement result set
+*/
+
+MYSQL_ROW_OFFSET STDCALL mysql_stmt_row_seek(MYSQL_STMT *stmt,
+                                             MYSQL_ROW_OFFSET row) {
+  MYSQL_ROW_OFFSET offset = stmt->data_cursor;
+  DBUG_ENTER("mysql_stmt_row_seek");
+
+  stmt->data_cursor = row;
+  DBUG_RETURN(offset);
+}
+
+/*
+  Return the current statement row cursor position
+*/
+
+MYSQL_ROW_OFFSET STDCALL mysql_stmt_row_tell(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_row_tell");
+
+  DBUG_RETURN(stmt->data_cursor);
+}
+
+/*
+  Move the stmt result set data cursor to specified row
+*/
+
+void STDCALL mysql_stmt_data_seek(MYSQL_STMT *stmt, my_ulonglong row) {
+  MYSQL_ROWS *tmp = stmt->result.data;
+  DBUG_ENTER("mysql_stmt_data_seek");
+  DBUG_PRINT("enter", ("row id to seek: %ld", (long)row));
+
+  for (; tmp && row; --row, tmp = tmp->next)
+    ;
+  stmt->data_cursor = tmp;
+  if (!row && tmp) {
+    /*  Rewind the counter */
+    stmt->read_row_func = stmt_read_row_buffered;
+    stmt->state = MYSQL_STMT_EXECUTE_DONE;
+  }
+  DBUG_VOID_RETURN;
+}
+
+/*
+  Return total rows the current statement result set
+*/
+
+my_ulonglong STDCALL mysql_stmt_num_rows(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_num_rows");
+
+  DBUG_RETURN(stmt->result.rows);
+}
+
+/*
+  Free the client side memory buffers, reset long data state
+  on client if necessary, and reset the server side statement if
+  this has been requested.
+*/
+
+static bool reset_stmt_handle(MYSQL_STMT *stmt, uint flags) {
+  /* If statement hasn't been prepared there is nothing to reset */
+  if ((int)stmt->state > (int)MYSQL_STMT_INIT_DONE) {
+    MYSQL *mysql = stmt->mysql;
+    MYSQL_DATA *result = &stmt->result;
+
+    /*
+      Reset stored result set if so was requested or it's a part
+      of cursor fetch.
+    */
+    if (flags & RESET_STORE_RESULT) {
+      /* Result buffered */
+      free_root(result->alloc, MYF(MY_KEEP_PREALLOC));
+      result->data = NULL;
+      result->rows = 0;
+      stmt->data_cursor = NULL;
+    }
+    if (flags & RESET_LONG_DATA) {
+      MYSQL_BIND *param = stmt->params, *param_end = param + stmt->param_count;
+      /* Clear long_data_used flags */
+      for (; param < param_end; param++) param->long_data_used = 0;
+    }
+    stmt->read_row_func = stmt_read_row_no_result_set;
+    if (mysql) {
+      if ((int)stmt->state > (int)MYSQL_STMT_PREPARE_DONE) {
+        if (mysql->unbuffered_fetch_owner == &stmt->unbuffered_fetch_cancelled)
+          mysql->unbuffered_fetch_owner = 0;
+        if (stmt->field_count && mysql->status != MYSQL_STATUS_READY) {
+          /* There is a result set and it belongs to this statement */
+          (*mysql->methods->flush_use_result)(mysql, false);
+          if (mysql->unbuffered_fetch_owner)
+            *mysql->unbuffered_fetch_owner = true;
+          mysql->status = MYSQL_STATUS_READY;
+        }
+      }
+      if (flags & RESET_SERVER_SIDE) {
+        /*
+          Reset the server side statement and close the server side
+          cursor if it exists.
+        */
+        uchar buff[MYSQL_STMT_HEADER]; /* packet header: 4 bytes for stmt id */
+        int4store(buff, stmt->stmt_id);
+        if ((*mysql->methods->advanced_command)(mysql, COM_STMT_RESET, buff,
+                                                sizeof(buff), 0, 0, 0, stmt)) {
+          set_stmt_errmsg(stmt, &mysql->net);
+          stmt->state = MYSQL_STMT_INIT_DONE;
+          return 1;
+        }
+      }
+    }
+    if (flags & RESET_CLEAR_ERROR) stmt_clear_error(stmt);
+    stmt->state = MYSQL_STMT_PREPARE_DONE;
+  }
+  return 0;
+}
+
+bool STDCALL mysql_stmt_free_result(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_free_result");
+
+  /* Free the client side and close the server side cursor if there is one */
+  DBUG_RETURN(reset_stmt_handle(
+      stmt, RESET_LONG_DATA | RESET_STORE_RESULT | RESET_CLEAR_ERROR));
+}
+
+/********************************************************************
+ statement error handling and close
+*********************************************************************/
+
+/*
+  Close the statement handle by freeing all alloced resources
+
+  SYNOPSIS
+    mysql_stmt_close()
+    stmt	       Statement handle
+
+  RETURN VALUES
+    0	ok
+    1	error
+*/
+
+bool STDCALL mysql_stmt_close(MYSQL_STMT *stmt) {
+  MYSQL *mysql = stmt->mysql;
+  int rc = 0;
+  DBUG_ENTER("mysql_stmt_close");
+
+  free_root(stmt->result.alloc, MYF(0));
+  free_root(stmt->mem_root, MYF(0));
+  free_root(&stmt->extension->fields_mem_root, MYF(0));
+
+  if (mysql) {
+    mysql->stmts = list_delete(mysql->stmts, &stmt->list);
+    /*
+      Clear NET error state: if the following commands come through
+      successfully, connection will still be usable for other commands.
+    */
+    net_clear_error(&mysql->net);
+    if ((int)stmt->state > (int)MYSQL_STMT_INIT_DONE) {
+      uchar buff[MYSQL_STMT_HEADER]; /* 4 bytes - stmt id */
+
+      if (mysql->unbuffered_fetch_owner == &stmt->unbuffered_fetch_cancelled)
+        mysql->unbuffered_fetch_owner = 0;
+      if (mysql->status != MYSQL_STATUS_READY) {
+        /*
+          Flush result set of the connection. If it does not belong
+          to this statement, set a warning.
+        */
+        (*mysql->methods->flush_use_result)(mysql, true);
+        if (mysql->unbuffered_fetch_owner)
+          *mysql->unbuffered_fetch_owner = true;
+        mysql->status = MYSQL_STATUS_READY;
+      }
+      int4store(buff, stmt->stmt_id);
+      /*
+        If stmt_command failed, it would have already raised
+        error using set_mysql_error. Caller should use
+        mysql_error() or mysql_errno() to find out details.
+        Memory allocated for stmt will be released regardless
+        of the error.
+      */
+      rc = stmt_command(mysql, COM_STMT_CLOSE, buff, 4, stmt);
+    }
+  }
+
+  my_free(stmt->result.alloc);
+  my_free(stmt->mem_root);
+  my_free(stmt->extension);
+  my_free(stmt);
+
+  DBUG_RETURN(rc != 0);
+}
+
+/*
+  Reset the statement buffers in server
+*/
+
+bool STDCALL mysql_stmt_reset(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_reset");
+  DBUG_ASSERT(stmt != 0);
+  if (!stmt->mysql) {
+    /* mysql can be reset in mysql_close called from mysql_reconnect */
+    set_stmt_error(stmt, CR_SERVER_LOST, unknown_sqlstate, NULL);
+    DBUG_RETURN(1);
+  }
+  /* Reset the client and server sides of the prepared statement */
+  DBUG_RETURN(reset_stmt_handle(
+      stmt, RESET_SERVER_SIDE | RESET_LONG_DATA | RESET_CLEAR_ERROR));
+}
+
+/*
+  Return statement error code
+*/
+
+uint STDCALL mysql_stmt_errno(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_errno");
+  DBUG_RETURN(stmt->last_errno);
+}
+
+const char *STDCALL mysql_stmt_sqlstate(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_sqlstate");
+  DBUG_RETURN(stmt->sqlstate);
+}
+
+/*
+  Return statement error message
+*/
+
+const char *STDCALL mysql_stmt_error(MYSQL_STMT *stmt) {
+  DBUG_ENTER("mysql_stmt_error");
+  DBUG_RETURN(stmt->last_error);
+}
+
+/********************************************************************
+ Transactional APIs
+*********************************************************************/
+
+/*
+  Commit the current transaction
+*/
+
+bool STDCALL mysql_commit(MYSQL *mysql) {
+  DBUG_ENTER("mysql_commit");
+  DBUG_RETURN((bool)mysql_real_query(mysql, "commit", 6));
+}
+
+/*
+  Rollback the current transaction
+*/
+
+bool STDCALL mysql_rollback(MYSQL *mysql) {
+  DBUG_ENTER("mysql_rollback");
+  DBUG_RETURN((bool)mysql_real_query(mysql, "rollback", 8));
+}
+
+/*
+  Set autocommit to either true or false
+*/
+
+bool STDCALL mysql_autocommit(MYSQL *mysql, bool auto_mode) {
+  DBUG_ENTER("mysql_autocommit");
+  DBUG_PRINT("enter", ("mode : %d", auto_mode));
+
+  DBUG_RETURN((bool)mysql_real_query(
+      mysql, auto_mode ? "set autocommit=1" : "set autocommit=0", 16));
+}
+
+/********************************************************************
+ Multi query execution + SPs APIs
+*********************************************************************/
+
+/*
+  Returns true/false to indicate whether any more query results exist
+  to be read using mysql_next_result()
+*/
+
+bool STDCALL mysql_more_results(MYSQL *mysql) {
+  bool res;
+  DBUG_ENTER("mysql_more_results");
+
+  res = ((mysql->server_status & SERVER_MORE_RESULTS_EXISTS) ? 1 : 0);
+  DBUG_PRINT("exit", ("More results exists ? %d", res));
+  DBUG_RETURN(res);
+}
+
+/*
+  Reads and returns the next query results
+*/
+int STDCALL mysql_next_result(MYSQL *mysql) {
+  DBUG_ENTER("mysql_next_result");
+
+  MYSQL_TRACE_STAGE(mysql, WAIT_FOR_RESULT);
+
+  if (mysql->status != MYSQL_STATUS_READY) {
+    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
+    DBUG_RETURN(1);
+  }
+
+  net_clear_error(&mysql->net);
+  mysql->affected_rows = ~(my_ulonglong)0;
+
+  if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS)
+    DBUG_RETURN((*mysql->methods->next_result)(mysql));
+  else {
+    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+  }
+
+  DBUG_RETURN(-1); /* No more results */
+}
+
+/*
+  This API reads the next statement result and returns a status to indicate
+  whether more results exist
+
+  @param[in]    mysql                                    connection handle
+
+  @retval       NET_ASYNC_ERROR                          Error
+  @retval       NET_ASYNC_NOT_READY                      reading next result not
+                                                         yet completed, call
+                                                         this API again
+  @retval       NET_ASYNC_COMPLETE                       finished reading result
+  @retval       NET_ASYNC_COMPLETE_NO_MORE_RESULTS       status to indicate if
+                                                         more results exist
+*/
+net_async_status STDCALL mysql_next_result_nonblocking(MYSQL *mysql) {
+  DBUG_ENTER(__func__);
+  net_async_status status;
+  if (mysql->status != MYSQL_STATUS_READY) {
+    set_mysql_error(mysql, CR_COMMANDS_OUT_OF_SYNC, unknown_sqlstate);
+    DBUG_RETURN(NET_ASYNC_ERROR);
+  }
+  net_clear_error(&mysql->net);
+  mysql->affected_rows = ~(my_ulonglong)0;
+
+  if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS) {
+    status = (*mysql->methods->next_result_nonblocking)(mysql);
+    DBUG_RETURN(status);
+  } else {
+    MYSQL_TRACE_STAGE(mysql, READY_FOR_COMMAND);
+  }
+
+  DBUG_RETURN(NET_ASYNC_COMPLETE_NO_MORE_RESULTS); /* No more results */
+}
+
+int STDCALL mysql_stmt_next_result(MYSQL_STMT *stmt) {
+  MYSQL *mysql = stmt->mysql;
+  int rc;
+  DBUG_ENTER("mysql_stmt_next_result");
+
+  if (!mysql) DBUG_RETURN(1);
+
+  if (stmt->last_errno) DBUG_RETURN(stmt->last_errno);
+
+  if (mysql->server_status & SERVER_MORE_RESULTS_EXISTS) {
+    if (reset_stmt_handle(stmt, RESET_STORE_RESULT)) DBUG_RETURN(1);
+  }
+
+  rc = mysql_next_result(mysql);
+
+  if (rc) {
+    set_stmt_errmsg(stmt, &mysql->net);
+    DBUG_RETURN(rc);
+  }
+
+  if (mysql->status == MYSQL_STATUS_GET_RESULT)
+    mysql->status = MYSQL_STATUS_STATEMENT_GET_RESULT;
+
+  stmt->state = MYSQL_STMT_EXECUTE_DONE;
+  stmt->bind_result_done = false;
+  stmt->field_count = mysql->field_count;
+
+  if (mysql->field_count) {
+    alloc_stmt_fields(stmt);
+    prepare_to_fetch_result(stmt);
+  }
+
+  DBUG_RETURN(0);
+}
+
+MYSQL_RES *STDCALL mysql_use_result(MYSQL *mysql) {
+  return (*mysql->methods->use_result)(mysql);
+}
+
+bool STDCALL mysql_read_query_result(MYSQL *mysql) {
+  return (*mysql->methods->read_query_result)(mysql);
+}
+
+int STDCALL mysql_reset_connection(MYSQL *mysql) {
+  DBUG_ENTER("mysql_reset_connection");
+  if (simple_command(mysql, COM_RESET_CONNECTION, 0, 0, 0))
+    DBUG_RETURN(1);
+  else {
+    mysql_detach_stmt_list(&mysql->stmts, "mysql_reset_connection");
+    /* reset some of the members in mysql */
+    mysql->insert_id = 0;
+    mysql->affected_rows = ~(my_ulonglong)0;
+    free_old_query(mysql);
+    mysql->status = MYSQL_STATUS_READY;
+    DBUG_RETURN(0);
+  }
+}