mysql2 0.2.24 → 0.3.0

data/ext/mysql2/client.c

@@ -1,68 +1,28 @@
 #include <mysql2_ext.h>
-
-#include <time.h>
+#include <client.h>
 #include <errno.h>
-#ifndef _WIN32
-#include <sys/types.h>
-#include <sys/socket.h>
-#endif
-#ifndef _MSC_VER
-#include <unistd.h>
-#endif
-#include <fcntl.h>
-#include "wait_for_single_fd.h"
-
-#include "mysql_enc_name_to_ruby.h"
 
 VALUE cMysql2Client;
 extern VALUE mMysql2, cMysql2Error;
-static VALUE sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array, sym_stream;
-static ID intern_merge, intern_merge_bang, intern_error_number_eql, intern_sql_state_eql;
+static VALUE intern_encoding_from_charset;
+static VALUE sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array;
+static ID intern_merge, intern_error_number_eql, intern_sql_state_eql;
 
-#ifndef HAVE_RB_HASH_DUP
-static VALUE rb_hash_dup(VALUE other) {
-  return rb_funcall(rb_cHash, rb_intern("[]"), 1, other);
-}
-#endif
-
-#define REQUIRE_INITIALIZED(wrapper) \
-  if (!wrapper->initialized) { \
-    rb_raise(cMysql2Error, "MySQL client is not initialized"); \
-  }
-
-#define REQUIRE_CONNECTED(wrapper) \
-  REQUIRE_INITIALIZED(wrapper) \
-  if (!wrapper->connected && !wrapper->reconnect_enabled) { \
+#define REQUIRE_OPEN_DB(wrapper) \
+  if(wrapper->closed) { \
     rb_raise(cMysql2Error, "closed MySQL connection"); \
   }
 
-#define REQUIRE_NOT_CONNECTED(wrapper) \
-  REQUIRE_INITIALIZED(wrapper) \
-  if (wrapper->connected) { \
-    rb_raise(cMysql2Error, "MySQL connection is already open"); \
-  }
-
 #define MARK_CONN_INACTIVE(conn) \
-  wrapper->active_thread = Qnil;
+  wrapper->active = 0
 
 #define GET_CLIENT(self) \
   mysql_client_wrapper *wrapper; \
   Data_Get_Struct(self, mysql_client_wrapper, wrapper)
 
-/*
- * compatability with mysql-connector-c, where LIBMYSQL_VERSION is the correct
- * variable to use, but MYSQL_SERVER_VERSION gives the correct numbers when
- * linking against the server itself
- */
-#ifdef LIBMYSQL_VERSION
-  #define MYSQL_LINK_VERSION LIBMYSQL_VERSION
-#else
-  #define MYSQL_LINK_VERSION MYSQL_SERVER_VERSION
-#endif
-
 /*
  * used to pass all arguments to mysql_real_connect while inside
- * rb_thread_call_without_gvl
+ * rb_thread_blocking_region
  */
 struct nogvl_connect_args {
   MYSQL *mysql;
@@ -77,23 +37,11 @@ struct nogvl_connect_args {
 
 /*
  * used to pass all arguments to mysql_send_query while inside
- * rb_thread_call_without_gvl
+ * rb_thread_blocking_region
  */
 struct nogvl_send_query_args {
   MYSQL *mysql;
   VALUE sql;
-  const char *sql_ptr;
-  long sql_len;
-  mysql_client_wrapper *wrapper;
-};
-
-/*
- * used to pass all arguments to mysql_select_db while inside
- * rb_thread_call_without_gvl
- */
-struct nogvl_select_db_args {
-  MYSQL *mysql;
-  char *db;
 };
 
 /*
@@ -122,136 +70,94 @@ static void rb_mysql_client_mark(void * wrapper) {
   mysql_client_wrapper * w = wrapper;
   if (w) {
     rb_gc_mark(w->encoding);
-    rb_gc_mark(w->active_thread);
   }
 }
 
 static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
   VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
   VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
-  VALUE e;
-
 #ifdef HAVE_RUBY_ENCODING_H
-  rb_enc_associate(rb_error_msg, rb_utf8_encoding());
-  rb_enc_associate(rb_sql_state, rb_usascii_encoding());
+  rb_encoding *default_internal_enc = rb_default_internal_encoding();
+  rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
+
+  rb_enc_associate(rb_error_msg, conn_enc);
+  rb_enc_associate(rb_sql_state, conn_enc);
+  if (default_internal_enc) {
+    rb_error_msg = rb_str_export_to_enc(rb_error_msg, default_internal_enc);
+    rb_sql_state = rb_str_export_to_enc(rb_sql_state, default_internal_enc);
+  }
 #endif
 
-  e = rb_funcall(cMysql2Error, rb_intern("new"), 2, rb_error_msg, LONG2FIX(wrapper->server_version));
+  VALUE e = rb_exc_new3(cMysql2Error, rb_error_msg);
   rb_funcall(e, intern_error_number_eql, 1, UINT2NUM(mysql_errno(wrapper->client)));
   rb_funcall(e, intern_sql_state_eql, 1, rb_sql_state);
   rb_exc_raise(e);
   return Qnil;
 }
 
-static void *nogvl_init(void *ptr) {
+static VALUE nogvl_init(void *ptr) {
   MYSQL *client;
-  mysql_client_wrapper *wrapper = (mysql_client_wrapper *)ptr;
 
   /* may initialize embedded server and read /etc/services off disk */
-  client = mysql_init(wrapper->client);
-
-  if (client) mysql2_set_local_infile(client, wrapper);
-
-  return (void*)(client ? Qtrue : Qfalse);
+  client = mysql_init((MYSQL *)ptr);
+  return client ? Qtrue : Qfalse;
 }
 
-static void *nogvl_connect(void *ptr) {
+static VALUE nogvl_connect(void *ptr) {
   struct nogvl_connect_args *args = ptr;
   MYSQL *client;
 
-  client = mysql_real_connect(args->mysql, args->host,
-                              args->user, args->passwd,
-                              args->db, args->port, args->unix_socket,
-                              args->client_flag);
+  do {
+    client = mysql_real_connect(args->mysql, args->host,
+                                args->user, args->passwd,
+                                args->db, args->port, args->unix_socket,
+                                args->client_flag);
+  } while (! client && errno == EINTR && (errno = 0) == 0);
 
-  return (void *)(client ? Qtrue : Qfalse);
+  return client ? Qtrue : Qfalse;
 }
 
+static VALUE nogvl_close(void *ptr) {
+  mysql_client_wrapper *wrapper;
 #ifndef _WIN32
-/*
- * Redirect clientfd to /dev/null for mysql_close and SSL_close to write,
- * shutdown, and close. The hack is needed to prevent shutdown() from breaking
- * a socket that may be in use by the parent or other processes after fork.
- *
- * /dev/null is used to absorb writes; previously a dummy socket was used, but
- * it could not abosrb writes and caused openssl to go into an infinite loop.
- *
- * Returns Qtrue or Qfalse (success or failure)
- *
- * Note: if this function is needed on Windows, use "nul" instead of "/dev/null"
- */
-static VALUE invalidate_fd(int clientfd)
-{
-#ifdef SOCK_CLOEXEC
-  /* Atomically set CLOEXEC on the new FD in case another thread forks */
-  int sockfd = open("/dev/null", O_RDWR | O_CLOEXEC);
-  if (sockfd < 0) {
-    /* Maybe SOCK_CLOEXEC is defined but not available on this kernel */
-    int sockfd = open("/dev/null", O_RDWR);
-    fcntl(sockfd, F_SETFD, FD_CLOEXEC);
-  }
-#else
-  /* Well we don't have SOCK_CLOEXEC, so just set FD_CLOEXEC quickly */
-  int sockfd = open("/dev/null", O_RDWR);
-  fcntl(sockfd, F_SETFD, FD_CLOEXEC);
+  int flags;
 #endif
+  wrapper = ptr;
+  if (!wrapper->closed) {
+    wrapper->closed = 1;
 
-  if (sockfd < 0) {
     /*
-     * Cannot raise here, because one or both of the following may be true:
-     * a) we have no GVL (in C Ruby)
-     * b) are running as a GC finalizer
+     * we'll send a QUIT message to the server, but that message is more of a
+     * formality than a hard requirement since the socket is getting shutdown
+     * anyways, so ensure the socket write does not block our interpreter
+     *
+     *
+     * if the socket is dead we have no chance of blocking,
+     * so ignore any potential fcntl errors since they don't matter
      */
-    return Qfalse;
-  }
-
-  dup2(sockfd, clientfd);
-  close(sockfd);
-
-  return Qtrue;
-}
-#endif /* _WIN32 */
-
-static void *nogvl_close(void *ptr) {
-  mysql_client_wrapper *wrapper;
-  wrapper = ptr;
-  if (wrapper->connected) {
-    wrapper->active_thread = Qnil;
-    wrapper->connected = 0;
 #ifndef _WIN32
-    /* Invalidate the socket before calling mysql_close(). This prevents
-     * mysql_close() from sending a mysql-QUIT or from calling shutdown() on
-     * the socket. The difference is that invalidate_fd will drop this
-     * process's reference to the socket only, while a QUIT or shutdown()
-     * would render the underlying connection unusable, interrupting other
-     * processes which share this object across a fork().
-     */
-    if (invalidate_fd(wrapper->client->net.fd) == Qfalse) {
-      fprintf(stderr, "[WARN] mysql2 failed to invalidate FD safely, leaking some memory\n");
-      close(wrapper->client->net.fd);
-      return NULL;
-    }
+    flags = fcntl(wrapper->client->net.fd, F_GETFL);
+    if (flags > 0 && !(flags & O_NONBLOCK))
+      fcntl(wrapper->client->net.fd, F_SETFL, flags | O_NONBLOCK);
+#else
+    u_long iMode;
+    iMode = 1;
+    ioctlsocket(wrapper->client->net.fd, FIONBIO, &iMode);
 #endif
 
-    mysql_close(wrapper->client); /* only used to free memory at this point */
+    mysql_close(wrapper->client);
+    xfree(wrapper->client);
   }
 
-  return NULL;
+  return Qnil;
 }
 
-static void rb_mysql_client_free(void *ptr) {
+static void rb_mysql_client_free(void * ptr) {
   mysql_client_wrapper *wrapper = (mysql_client_wrapper *)ptr;
-  decr_mysql2_client(wrapper);
-}
 
-void decr_mysql2_client(mysql_client_wrapper *wrapper)
-{
-  wrapper->refcount--;
-  if (wrapper->refcount == 0) {
-    nogvl_close(wrapper);
-    xfree(wrapper->client);
-    xfree(wrapper);
-  }
+  nogvl_close(wrapper);
+
+  xfree(ptr);
 }
 
 static VALUE allocate(VALUE klass) {
@@ -259,25 +165,13 @@ static VALUE allocate(VALUE klass) {
   mysql_client_wrapper * wrapper;
   obj = Data_Make_Struct(klass, mysql_client_wrapper, rb_mysql_client_mark, rb_mysql_client_free, wrapper);
   wrapper->encoding = Qnil;
-  wrapper->active_thread = Qnil;
-  wrapper->server_version = 0;
-  wrapper->reconnect_enabled = 0;
-  wrapper->connect_timeout = 0;
-  wrapper->connected = 0; /* means that a database connection is open */
-  wrapper->initialized = 0; /* means that that the wrapper is initialized */
-  wrapper->refcount = 1;
+  wrapper->active = 0;
+  wrapper->closed = 1;
   wrapper->client = (MYSQL*)xmalloc(sizeof(MYSQL));
   return obj;
 }
 
-/* call-seq:
- *    Mysql2::Client.escape(string)
- *
- * Escape +string+ so that it may be used in a SQL statement.
- * Note that this escape method is not connection encoding aware.
- * If you need encoding support use Mysql2::Client#escape instead.
- */
-static VALUE rb_mysql_client_escape(RB_MYSQL_UNUSED VALUE klass, VALUE str) {
+static VALUE rb_mysql_client_escape(VALUE klass, VALUE str) {
   unsigned char *newStr;
   VALUE rb_str;
   unsigned long newLen, oldLen;
@@ -289,7 +183,7 @@ static VALUE rb_mysql_client_escape(RB_MYSQL_UNUSED VALUE klass, VALUE str) {
 
   newLen = mysql_escape_string((char *)newStr, StringValuePtr(str), oldLen);
   if (newLen == oldLen) {
-    /* no need to return a new ruby string if nothing changed */
+    // no need to return a new ruby string if nothing changed
     xfree(newStr);
     return str;
   } else {
@@ -302,81 +196,24 @@ static VALUE rb_mysql_client_escape(RB_MYSQL_UNUSED VALUE klass, VALUE str) {
   }
 }
 
-static VALUE rb_mysql_client_warning_count(VALUE self) {
-  unsigned int warning_count;
-  GET_CLIENT(self);
-
-  warning_count = mysql_warning_count(wrapper->client);
-
-  return UINT2NUM(warning_count);
-}
-
-static VALUE rb_mysql_info(VALUE self) {
-  const char *info;
-  VALUE rb_str;
-  GET_CLIENT(self);
-
-  info = mysql_info(wrapper->client);
-
-  if (info == NULL) {
-    return Qnil;
-  }
-
-  rb_str = rb_str_new2(info);
-#ifdef HAVE_RUBY_ENCODING_H
-  rb_enc_associate(rb_str, rb_utf8_encoding());
-#endif
-
-  return rb_str;
-}
-
 static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE port, VALUE database, VALUE socket, VALUE flags) {
   struct nogvl_connect_args args;
-  time_t start_time, end_time;
-  unsigned int elapsed_time, connect_timeout;
-  VALUE rv;
   GET_CLIENT(self);
 
-  args.host = NIL_P(host) ? NULL : StringValuePtr(host);
+  args.host = NIL_P(host) ? "localhost" : StringValuePtr(host);
   args.unix_socket = NIL_P(socket) ? NULL : StringValuePtr(socket);
-  args.port = NIL_P(port) ? 0 : NUM2INT(port);
+  args.port = NIL_P(port) ? 3306 : NUM2INT(port);
   args.user = NIL_P(user) ? NULL : StringValuePtr(user);
   args.passwd = NIL_P(pass) ? NULL : StringValuePtr(pass);
   args.db = NIL_P(database) ? NULL : StringValuePtr(database);
   args.mysql = wrapper->client;
   args.client_flag = NUM2ULONG(flags);
 
-  if (wrapper->connect_timeout)
-    time(&start_time);
-  rv = (VALUE) rb_thread_call_without_gvl(nogvl_connect, &args, RUBY_UBF_IO, 0);
-  if (rv == Qfalse) {
-    while (rv == Qfalse && errno == EINTR) {
-      if (wrapper->connect_timeout) {
-        time(&end_time);
-        /* avoid long connect timeout from system time changes */
-        if (end_time < start_time)
-          start_time = end_time;
-        elapsed_time = end_time - start_time;
-        /* avoid an early timeout due to time truncating milliseconds off the start time */
-        if (elapsed_time > 0)
-          elapsed_time--;
-        if (elapsed_time >= wrapper->connect_timeout)
-          break;
-        connect_timeout = wrapper->connect_timeout - elapsed_time;
-        mysql_options(wrapper->client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout);
-      }
-      errno = 0;
-      rv = (VALUE) rb_thread_call_without_gvl(nogvl_connect, &args, RUBY_UBF_IO, 0);
-    }
-    /* restore the connect timeout for reconnecting */
-    if (wrapper->connect_timeout)
-      mysql_options(wrapper->client, MYSQL_OPT_CONNECT_TIMEOUT, &wrapper->connect_timeout);
-    if (rv == Qfalse)
-      return rb_raise_mysql2_error(wrapper);
+  if (rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0) == Qfalse) {
+    // unable to connect
+    return rb_raise_mysql2_error(wrapper);
   }
 
-  wrapper->server_version = mysql_get_server_version(wrapper->client);
-  wrapper->connected = 1;
   return self;
 }
 
@@ -389,8 +226,8 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
 static VALUE rb_mysql_client_close(VALUE self) {
   GET_CLIENT(self);
 
-  if (wrapper->connected) {
-    rb_thread_call_without_gvl(nogvl_close, wrapper, RUBY_UBF_IO, 0);
+  if (!wrapper->closed) {
+    rb_thread_blocking_region(nogvl_close, wrapper, RUBY_UBF_IO, 0);
   }
 
   return Qnil;
@@ -401,24 +238,15 @@ static VALUE rb_mysql_client_close(VALUE self) {
  * enough to fit in a socket buffer, but sometimes large UPDATE and
  * INSERTs will cause the process to block
  */
-static void *nogvl_send_query(void *ptr) {
+static VALUE nogvl_send_query(void *ptr) {
   struct nogvl_send_query_args *args = ptr;
   int rv;
+  const char *sql = StringValuePtr(args->sql);
+  long sql_len = RSTRING_LEN(args->sql);
 
-  rv = mysql_send_query(args->mysql, args->sql_ptr, args->sql_len);
+  rv = mysql_send_query(args->mysql, sql, sql_len);
 
-  return (void*)(rv == 0 ? Qtrue : Qfalse);
-}
-
-static VALUE do_send_query(void *args) {
-  struct nogvl_send_query_args *query_args = args;
-  mysql_client_wrapper *wrapper = query_args->wrapper;
-  if ((VALUE)rb_thread_call_without_gvl(nogvl_send_query, args, RUBY_UBF_IO, 0) == Qfalse) {
-    /* an error occurred, we're not active anymore */
-    MARK_CONN_INACTIVE(self);
-    return rb_raise_mysql2_error(wrapper);
-  }
-  return Qnil;
+  return rv == 0 ? Qtrue : Qfalse;
 }
 
 /*
@@ -426,129 +254,117 @@ static VALUE do_send_query(void *args) {
  * response can overflow the socket buffers and cause us to eventually
  * block while calling mysql_read_query_result
  */
-static void *nogvl_read_query_result(void *ptr) {
+static VALUE nogvl_read_query_result(void *ptr) {
   MYSQL * client = ptr;
   my_bool res = mysql_read_query_result(client);
 
-  return (void *)(res == 0 ? Qtrue : Qfalse);
-}
-
-static void *nogvl_do_result(void *ptr, char use_result) {
-  mysql_client_wrapper *wrapper;
-  MYSQL_RES *result;
-
-  wrapper = (mysql_client_wrapper *)ptr;
-  if(use_result) {
-    result = mysql_use_result(wrapper->client);
-  } else {
-    result = mysql_store_result(wrapper->client);
-  }
-
-  /* once our result is stored off, this connection is
-     ready for another command to be issued */
-  wrapper->active_thread = Qnil;
-
-  return result;
+  return res == 0 ? Qtrue : Qfalse;
 }
 
 /* mysql_store_result may (unlikely) read rows off the socket */
-static void *nogvl_store_result(void *ptr) {
-  return nogvl_do_result(ptr, 0);
-}
-
-static void *nogvl_use_result(void *ptr) {
-  return nogvl_do_result(ptr, 1);
+static VALUE nogvl_store_result(void *ptr) {
+  MYSQL * client = ptr;
+  return (VALUE)mysql_store_result(client);
 }
 
-/* call-seq:
- *    client.async_result
- *
- * Returns the result for the last async issued query.
- */
 static VALUE rb_mysql_client_async_result(VALUE self) {
   MYSQL_RES * result;
   VALUE resultObj;
-  VALUE current, is_streaming;
+#ifdef HAVE_RUBY_ENCODING_H
+  mysql2_result_wrapper * result_wrapper;
+#endif
   GET_CLIENT(self);
 
-  /* if we're not waiting on a result, do nothing */
-  if (NIL_P(wrapper->active_thread))
-    return Qnil;
-
-  REQUIRE_CONNECTED(wrapper);
-  if ((VALUE)rb_thread_call_without_gvl(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
-    /* an error occurred, mark this connection inactive */
+  REQUIRE_OPEN_DB(wrapper);
+  if (rb_thread_blocking_region(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
+    // an error occurred, mark this connection inactive
     MARK_CONN_INACTIVE(self);
     return rb_raise_mysql2_error(wrapper);
   }
 
-  is_streaming = rb_hash_aref(rb_iv_get(self, "@current_query_options"), sym_stream);
-  if(is_streaming == Qtrue) {
-    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
-  } else {
-    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
-  }
+  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper->client, RUBY_UBF_IO, 0);
+
+  // we have our result, mark this connection inactive
+  MARK_CONN_INACTIVE(self);
 
   if (result == NULL) {
-    if (mysql_errno(wrapper->client) != 0) {
-      MARK_CONN_INACTIVE(self);
+    if (mysql_field_count(wrapper->client) != 0) {
       rb_raise_mysql2_error(wrapper);
     }
-    /* no data and no error, so query was not a SELECT */
     return Qnil;
   }
 
-  current = rb_hash_dup(rb_iv_get(self, "@current_query_options"));
-  RB_GC_GUARD(current);
-  Check_Type(current, T_HASH);
-  resultObj = rb_mysql_result_to_obj(self, wrapper->encoding, current, result);
+  resultObj = rb_mysql_result_to_obj(result);
+  // pass-through query options for result construction later
+  rb_iv_set(resultObj, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), rb_intern("dup"), 0));
 
+#ifdef HAVE_RUBY_ENCODING_H
+  GetMysql2Result(resultObj, result_wrapper);
+  result_wrapper->encoding = wrapper->encoding;
+#endif
   return resultObj;
 }
 
-#ifndef _WIN32
-struct async_query_args {
-  int fd;
-  VALUE self;
-};
-
-static VALUE disconnect_and_raise(VALUE self, VALUE error) {
+static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
+  struct nogvl_send_query_args args;
+  fd_set fdset;
+  int fd, retval;
+  int async = 0;
+  VALUE opts, defaults, read_timeout;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *conn_enc;
+#endif
+  struct timeval tv;
+  struct timeval* tvp;
+  long int sec;
+  VALUE result;
   GET_CLIENT(self);
 
-  wrapper->active_thread = Qnil;
-  wrapper->connected = 0;
+  REQUIRE_OPEN_DB(wrapper);
+  args.mysql = wrapper->client;
 
-  /* Invalidate the MySQL socket to prevent further communication.
-   * The GC will come along later and call mysql_close to free it.
-   */
-  if (invalidate_fd(wrapper->client->net.fd) == Qfalse) {
-    fprintf(stderr, "[WARN] mysql2 failed to invalidate FD safely, closing unsafely\n");
-    close(wrapper->client->net.fd);
+  // see if this connection is still waiting on a result from a previous query
+  if (wrapper->active == 0) {
+    // mark this connection active
+    wrapper->active = 1;
+  } else {
+    rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result");
   }
 
-  rb_exc_raise(error);
+  defaults = rb_iv_get(self, "@query_options");
+  if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) {
+    opts = rb_funcall(defaults, intern_merge, 1, opts);
+    rb_iv_set(self, "@query_options", opts);
 
-  return Qnil;
-}
+    if (rb_hash_aref(opts, sym_async) == Qtrue) {
+      async = 1;
+    }
+  } else {
+    opts = defaults;
+  }
 
-static VALUE do_query(void *args) {
-  struct async_query_args *async_args;
-  struct timeval tv;
-  struct timeval* tvp;
-  long int sec;
-  int retval;
-  VALUE read_timeout;
+  Check_Type(args.sql, T_STRING);
+#ifdef HAVE_RUBY_ENCODING_H
+  conn_enc = rb_to_encoding(wrapper->encoding);
+  // ensure the string is in the encoding the connection is expecting
+  args.sql = rb_str_export_to_enc(args.sql, conn_enc);
+#endif
+
+  if (rb_thread_blocking_region(nogvl_send_query, &args, RUBY_UBF_IO, 0) == Qfalse) {
+    // an error occurred, we're not active anymore
+    MARK_CONN_INACTIVE(self);
+    return rb_raise_mysql2_error(wrapper);
+  }
 
-  async_args = (struct async_query_args *)args;
-  read_timeout = rb_iv_get(async_args->self, "@read_timeout");
+  read_timeout = rb_iv_get(self, "@read_timeout");
 
   tvp = NULL;
   if (!NIL_P(read_timeout)) {
     Check_Type(read_timeout, T_FIXNUM);
     tvp = &tv;
     sec = FIX2INT(read_timeout);
-    /* TODO: support partial seconds?
-       also, this check is here for sanity, we also check up in Ruby */
+    // TODO: support partial seconds?
+    // also, this check is here for sanity, we also check up in Ruby
     if (sec >= 0) {
       tvp->tv_sec = sec;
     } else {
@@ -557,163 +373,55 @@ static VALUE do_query(void *args) {
     tvp->tv_usec = 0;
   }
 
-  for(;;) {
-    retval = rb_wait_for_single_fd(async_args->fd, RB_WAITFD_IN, tvp);
-
-    if (retval == 0) {
-      rb_raise(cMysql2Error, "Timeout waiting for a response from the last query. (waited %d seconds)", FIX2INT(read_timeout));
-    }
-
-    if (retval < 0) {
-      rb_sys_fail(0);
-    }
-
-    if (retval > 0) {
-      break;
-    }
-  }
-
-  return Qnil;
-}
-#else
-static VALUE finish_and_mark_inactive(void *args) {
-  VALUE self;
-  MYSQL_RES *result;
-
-  self = (VALUE)args;
-
-  GET_CLIENT(self);
-
-  if (!NIL_P(wrapper->active_thread)) {
-    /* if we got here, the result hasn't been read off the wire yet
-       so lets do that and then throw it away because we have no way
-       of getting it back up to the caller from here */
-    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
-    mysql_free_result(result);
-
-    wrapper->active_thread = Qnil;
-  }
+  if (!async) {
+    // the below code is largely from do_mysql
+    // http://github.com/datamapper/do
+    fd = wrapper->client->net.fd;
+    for(;;) {
+      int fd_set_fd = fd;
 
-  return Qnil;
-}
+#ifdef _WIN32
+      WSAPROTOCOL_INFO wsa_pi;
+      // dupicate the SOCKET from libmysql
+      int r = WSADuplicateSocket(fd, GetCurrentProcessId(), &wsa_pi);
+      SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
+      // create the CRT fd so ruby can get back to the SOCKET
+      fd_set_fd = _open_osfhandle(s, O_RDWR|O_BINARY);
 #endif
 
-/* call-seq:
- *    client.abandon_results!
- *
- * When using MULTI_STATEMENTS support, calling this will throw
- * away any unprocessed results as fast as it can in order to
- * put the connection back into a state where queries can be issued
- * again.
- */
-static VALUE rb_mysql_client_abandon_results(VALUE self) {
-  MYSQL_RES *result;
-  int ret;
+      FD_ZERO(&fdset);
+      FD_SET(fd_set_fd, &fdset);
 
-  GET_CLIENT(self);
+      retval = rb_thread_select(fd_set_fd + 1, &fdset, NULL, NULL, tvp);
 
-  while (mysql_more_results(wrapper->client) == 1) {
-    ret = mysql_next_result(wrapper->client);
-    if (ret > 0) {
-      rb_raise_mysql2_error(wrapper);
-    }
-
-    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
-
-    if (result != NULL) {
-      mysql_free_result(result);
-    }
-  }
-
-  return Qnil;
-}
-
-/* call-seq:
- *    client.query(sql, options = {})
- *
- * Query the database with +sql+, with optional +options+.  For the possible
- * options, see @@default_query_options on the Mysql2::Client class.
- */
-static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
-#ifndef _WIN32
-  struct async_query_args async_args;
-#endif
-  struct nogvl_send_query_args args;
-  int async = 0;
-  VALUE opts, current;
-  VALUE thread_current = rb_thread_current();
-#ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *conn_enc;
+#ifdef _WIN32
+      // cleanup the CRT fd
+      _close(fd_set_fd);
+      // cleanup the duplicated SOCKET
+      closesocket(s);
 #endif
-  GET_CLIENT(self);
-
-  REQUIRE_CONNECTED(wrapper);
-  args.mysql = wrapper->client;
 
-  current = rb_hash_dup(rb_iv_get(self, "@query_options"));
-  RB_GC_GUARD(current);
-  Check_Type(current, T_HASH);
-  rb_iv_set(self, "@current_query_options", current);
+      if (retval == 0) {
+        rb_raise(cMysql2Error, "Timeout waiting for a response from the last query. (waited %d seconds)", FIX2INT(read_timeout));
+      }
 
-  if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) {
-    rb_funcall(current, intern_merge_bang, 1, opts);
+      if (retval < 0) {
+        rb_sys_fail(0);
+      }
 
-    if (rb_hash_aref(current, sym_async) == Qtrue) {
-      async = 1;
+      if (retval > 0) {
+        break;
+      }
     }
-  }
 
-  Check_Type(args.sql, T_STRING);
-#ifdef HAVE_RUBY_ENCODING_H
-  conn_enc = rb_to_encoding(wrapper->encoding);
-  /* ensure the string is in the encoding the connection is expecting */
-  args.sql = rb_str_export_to_enc(args.sql, conn_enc);
-#endif
-  args.sql_ptr = StringValuePtr(args.sql);
-  args.sql_len = RSTRING_LEN(args.sql);
-
-  /* see if this connection is still waiting on a result from a previous query */
-  if (NIL_P(wrapper->active_thread)) {
-    /* mark this connection active */
-    wrapper->active_thread = thread_current;
-  } else if (wrapper->active_thread == thread_current) {
-    rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result");
-  } else {
-    VALUE inspect = rb_inspect(wrapper->active_thread);
-    const char *thr = StringValueCStr(inspect);
-
-    rb_raise(cMysql2Error, "This connection is in use by: %s", thr);
-    RB_GC_GUARD(inspect);
-  }
-
-  args.wrapper = wrapper;
-
-#ifndef _WIN32
-  rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0);
-
-  if (!async) {
-    async_args.fd = wrapper->client->net.fd;
-    async_args.self = self;
+    result = rb_mysql_client_async_result(self);
 
-    rb_rescue2(do_query, (VALUE)&async_args, disconnect_and_raise, self, rb_eException, (VALUE)0);
-
-    return rb_mysql_client_async_result(self);
+    return result;
   } else {
     return Qnil;
   }
-#else
-  do_send_query(&args);
-
-  /* this will just block until the result is ready */
-  return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self);
-#endif
 }
 
-/* call-seq:
- *    client.escape(string)
- *
- * Escape +string+ so that it may be used in a SQL statement.
- */
 static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
   unsigned char *newStr;
   VALUE rb_str;
@@ -724,12 +432,12 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
 #endif
   GET_CLIENT(self);
 
-  REQUIRE_CONNECTED(wrapper);
+  REQUIRE_OPEN_DB(wrapper);
   Check_Type(str, T_STRING);
 #ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
   conn_enc = rb_to_encoding(wrapper->encoding);
-  /* ensure the string is in the encoding the connection is expecting */
+  // ensure the string is in the encoding the connection is expecting
   str = rb_str_export_to_enc(str, conn_enc);
 #endif
 
@@ -738,7 +446,7 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
 
   newLen = mysql_real_escape_string(wrapper->client, (char *)newStr, StringValuePtr(str), oldLen);
   if (newLen == oldLen) {
-    /* no need to return a new ruby string if nothing changed */
+    // no need to return a new ruby string if nothing changed
     xfree(newStr);
     return str;
   } else {
@@ -754,102 +462,13 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
   }
 }
 
-static VALUE _mysql_client_options(VALUE self, int opt, VALUE value) {
-  int result;
-  const void *retval = NULL;
-  unsigned int intval = 0;
-  const char * charval = NULL;
-  my_bool boolval;
-
-  GET_CLIENT(self);
-
-  REQUIRE_NOT_CONNECTED(wrapper);
-
-  if (NIL_P(value))
-      return Qfalse;
-
-  switch(opt) {
-    case MYSQL_OPT_CONNECT_TIMEOUT:
-      intval = NUM2UINT(value);
-      retval = &intval;
-      break;
-
-    case MYSQL_OPT_READ_TIMEOUT:
-      intval = NUM2UINT(value);
-      retval = &intval;
-      break;
-
-    case MYSQL_OPT_WRITE_TIMEOUT:
-      intval = NUM2UINT(value);
-      retval = &intval;
-      break;
-
-    case MYSQL_OPT_LOCAL_INFILE:
-      intval = (value == Qfalse ? 0 : 1);
-      retval = &intval;
-      break;
-
-    case MYSQL_OPT_RECONNECT:
-      boolval = (value == Qfalse ? 0 : 1);
-      retval = &boolval;
-      break;
-
-    case MYSQL_SECURE_AUTH:
-      boolval = (value == Qfalse ? 0 : 1);
-      retval = &boolval;
-      break;
-
-    case MYSQL_READ_DEFAULT_FILE:
-      charval = (const char *)StringValuePtr(value);
-      retval  = charval;
-      break;
-
-    case MYSQL_READ_DEFAULT_GROUP:
-      charval = (const char *)StringValuePtr(value);
-      retval  = charval;
-      break;
-
-    case MYSQL_INIT_COMMAND:
-      charval = (const char *)StringValuePtr(value);
-      retval  = charval;
-      break;
-
-    default:
-      return Qfalse;
-  }
-
-  result = mysql_options(wrapper->client, opt, retval);
-
-  /* Zero means success */
-  if (result != 0) {
-    rb_warn("%s\n", mysql_error(wrapper->client));
-  } else {
-    /* Special case for options that are stored in the wrapper struct */
-    switch (opt) {
-      case MYSQL_OPT_RECONNECT:
-        wrapper->reconnect_enabled = boolval;
-        break;
-      case MYSQL_OPT_CONNECT_TIMEOUT:
-        wrapper->connect_timeout = intval;
-        break;
-    }
-  }
-
-  return (result == 0) ? Qtrue : Qfalse;
-}
-
-/* call-seq:
- *    client.info
- *
- * Returns a string that represents the client library version.
- */
 static VALUE rb_mysql_client_info(VALUE self) {
   VALUE version, client_info;
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc;
   rb_encoding *conn_enc;
-  GET_CLIENT(self);
 #endif
+  GET_CLIENT(self);
   version = rb_hash_new();
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -869,11 +488,6 @@ static VALUE rb_mysql_client_info(VALUE self) {
   return version;
 }
 
-/* call-seq:
- *    client.server_info
- *
- * Returns a string that represents the server version number
- */
 static VALUE rb_mysql_client_server_info(VALUE self) {
   VALUE version, server_info;
 #ifdef HAVE_RUBY_ENCODING_H
@@ -882,7 +496,7 @@ static VALUE rb_mysql_client_server_info(VALUE self) {
 #endif
   GET_CLIENT(self);
 
-  REQUIRE_CONNECTED(wrapper);
+  REQUIRE_OPEN_DB(wrapper);
 #ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
   conn_enc = rb_to_encoding(wrapper->encoding);
@@ -901,48 +515,34 @@ static VALUE rb_mysql_client_server_info(VALUE self) {
   return version;
 }
 
-/* call-seq:
- *    client.socket
- *
- * Return the file descriptor number for this client.
- */
 static VALUE rb_mysql_client_socket(VALUE self) {
   GET_CLIENT(self);
-#ifndef _WIN32
-  {
-    int fd_set_fd;
-    REQUIRE_CONNECTED(wrapper);
-    fd_set_fd = wrapper->client->net.fd;
-    return INT2NUM(fd_set_fd);
-  }
+  REQUIRE_OPEN_DB(wrapper);
+  int fd_set_fd = wrapper->client->net.fd;
+#ifdef _WIN32
+  WSAPROTOCOL_INFO wsa_pi;
+  // dupicate the SOCKET from libmysql
+  int r = WSADuplicateSocket(wrapper->client->net.fd, GetCurrentProcessId(), &wsa_pi);
+  SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
+  // create the CRT fd so ruby can get back to the SOCKET
+  fd_set_fd = _open_osfhandle(s, O_RDWR|O_BINARY);
+  return INT2NUM(fd_set_fd);
 #else
-  rb_raise(cMysql2Error, "Raw access to the mysql file descriptor isn't supported on Windows");
+  return INT2NUM(fd_set_fd);
 #endif
 }
 
-/* call-seq:
- *    client.last_id
- *
- * Returns the value generated for an AUTO_INCREMENT column by the previous INSERT or UPDATE
- * statement.
- */
 static VALUE rb_mysql_client_last_id(VALUE self) {
   GET_CLIENT(self);
-  REQUIRE_CONNECTED(wrapper);
+  REQUIRE_OPEN_DB(wrapper);
   return ULL2NUM(mysql_insert_id(wrapper->client));
 }
 
-/* call-seq:
- *    client.affected_rows
- *
- * returns the number of rows changed, deleted, or inserted by the last statement
- * if it was an UPDATE, DELETE, or INSERT.
- */
 static VALUE rb_mysql_client_affected_rows(VALUE self) {
   my_ulonglong retVal;
   GET_CLIENT(self);
 
-  REQUIRE_CONNECTED(wrapper);
+  REQUIRE_OPEN_DB(wrapper);
   retVal = mysql_affected_rows(wrapper->client);
   if (retVal == (my_ulonglong)-1) {
     rb_raise_mysql2_error(wrapper);
@@ -950,227 +550,93 @@ static VALUE rb_mysql_client_affected_rows(VALUE self) {
   return ULL2NUM(retVal);
 }
 
-/* call-seq:
- *    client.thread_id
- *
- * Returns the thread ID of the current connection.
- */
 static VALUE rb_mysql_client_thread_id(VALUE self) {
   unsigned long retVal;
   GET_CLIENT(self);
 
-  REQUIRE_CONNECTED(wrapper);
+  REQUIRE_OPEN_DB(wrapper);
   retVal = mysql_thread_id(wrapper->client);
   return ULL2NUM(retVal);
 }
 
-static void *nogvl_select_db(void *ptr) {
-  struct nogvl_select_db_args *args = ptr;
-
-  if (mysql_select_db(args->mysql, args->db) == 0)
-    return (void *)Qtrue;
-  else
-    return (void *)Qfalse;
-}
-
-/* call-seq:
- *    client.select_db(name)
- *
- * Causes the database specified by +name+ to become the default (current)
- * database on the connection specified by mysql.
- */
-static VALUE rb_mysql_client_select_db(VALUE self, VALUE db)
+static VALUE nogvl_ping(void *ptr)
 {
-  struct nogvl_select_db_args args;
-
-  GET_CLIENT(self);
-  REQUIRE_CONNECTED(wrapper);
-
-  args.mysql = wrapper->client;
-  args.db = StringValuePtr(db);
-
-  if (rb_thread_call_without_gvl(nogvl_select_db, &args, RUBY_UBF_IO, 0) == Qfalse)
-    rb_raise_mysql2_error(wrapper);
-
-  return db;
-}
-
-static void *nogvl_ping(void *ptr) {
   MYSQL *client = ptr;
 
-  return (void *)(mysql_ping(client) == 0 ? Qtrue : Qfalse);
+  return mysql_ping(client) == 0 ? Qtrue : Qfalse;
 }
 
-/* call-seq:
- *    client.ping
- *
- * Checks whether the connection to the server is working. If the connection
- * has gone down and auto-reconnect is enabled an attempt to reconnect is made.
- * If the connection is down and auto-reconnect is disabled, ping returns an
- * error.
- */
 static VALUE rb_mysql_client_ping(VALUE self) {
   GET_CLIENT(self);
 
-  if (!wrapper->connected) {
+  if (wrapper->closed) {
     return Qfalse;
   } else {
-    return (VALUE)rb_thread_call_without_gvl(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
-  }
-}
-
-/* call-seq:
- *    client.more_results?
- *
- * Returns true or false if there are more results to process.
- */
-static VALUE rb_mysql_client_more_results(VALUE self)
-{
-  GET_CLIENT(self);
-    if (mysql_more_results(wrapper->client) == 0)
-      return Qfalse;
-    else
-      return Qtrue;
-}
-
-/* call-seq:
- *    client.next_result
- *
- * Fetch the next result set from the server.
- * Returns nothing.
- */
-static VALUE rb_mysql_client_next_result(VALUE self)
-{
-    int ret;
-    GET_CLIENT(self);
-    ret = mysql_next_result(wrapper->client);
-    if (ret > 0) {
-      rb_raise_mysql2_error(wrapper);
-      return Qfalse;
-    } else if (ret == 0) {
-      return Qtrue;
-    } else {
-      return Qfalse;
-    }
-}
-
-/* call-seq:
- *    client.store_result
- *
- * Return the next result object from a query which
- * yielded multiple result sets.
- */
-static VALUE rb_mysql_client_store_result(VALUE self)
-{
-  MYSQL_RES * result;
-  VALUE resultObj;
-  VALUE current;
-  GET_CLIENT(self);
-
-  result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
-
-  if (result == NULL) {
-    if (mysql_errno(wrapper->client) != 0) {
-      rb_raise_mysql2_error(wrapper);
-    }
-    /* no data and no error, so query was not a SELECT */
-    return Qnil;
+    return rb_thread_blocking_region(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
   }
-
-  current = rb_hash_dup(rb_iv_get(self, "@current_query_options"));
-  RB_GC_GUARD(current);
-  Check_Type(current, T_HASH);
-  resultObj = rb_mysql_result_to_obj(self, wrapper->encoding, current, result);
-
-  return resultObj;
 }
 
 #ifdef HAVE_RUBY_ENCODING_H
-/* call-seq:
- *    client.encoding
- *
- * Returns the encoding set on the client.
- */
 static VALUE rb_mysql_client_encoding(VALUE self) {
   GET_CLIENT(self);
   return wrapper->encoding;
 }
 #endif
 
-/* call-seq:
- *    client.reconnect = true
- *
- * Enable or disable the automatic reconnect behavior of libmysql.
- * Read http://dev.mysql.com/doc/refman/5.5/en/auto-reconnect.html
- * for more information.
- */
 static VALUE set_reconnect(VALUE self, VALUE value) {
-  return _mysql_client_options(self, MYSQL_OPT_RECONNECT, value);
-}
+  my_bool reconnect;
+  GET_CLIENT(self);
 
-static VALUE set_local_infile(VALUE self, VALUE value) {
-  return _mysql_client_options(self, MYSQL_OPT_LOCAL_INFILE, value);
-}
+  if(!NIL_P(value)) {
+    reconnect = value == Qfalse ? 0 : 1;
 
-static VALUE set_connect_timeout(VALUE self, VALUE value) {
-  long int sec;
-  Check_Type(value, T_FIXNUM);
-  sec = FIX2INT(value);
-  if (sec < 0) {
-    rb_raise(cMysql2Error, "connect_timeout must be a positive integer, you passed %ld", sec);
+    /* set default reconnect behavior */
+    if (mysql_options(wrapper->client, MYSQL_OPT_RECONNECT, &reconnect)) {
+      /* TODO: warning - unable to set reconnect behavior */
+      rb_warn("%s\n", mysql_error(wrapper->client));
+    }
   }
-  return _mysql_client_options(self, MYSQL_OPT_CONNECT_TIMEOUT, value);
+  return value;
 }
 
-static VALUE set_read_timeout(VALUE self, VALUE value) {
-  long int sec;
-  Check_Type(value, T_FIXNUM);
-  sec = FIX2INT(value);
-  if (sec < 0) {
-    rb_raise(cMysql2Error, "read_timeout must be a positive integer, you passed %ld", sec);
-  }
-  /* Set the instance variable here even though _mysql_client_options
-     might not succeed, because the timeout is used in other ways
-     elsewhere */
-  rb_iv_set(self, "@read_timeout", value);
-  return _mysql_client_options(self, MYSQL_OPT_READ_TIMEOUT, value);
-}
+static VALUE set_connect_timeout(VALUE self, VALUE value) {
+  unsigned int connect_timeout = 0;
+  GET_CLIENT(self);
 
-static VALUE set_write_timeout(VALUE self, VALUE value) {
-  long int sec;
-  Check_Type(value, T_FIXNUM);
-  sec = FIX2INT(value);
-  if (sec < 0) {
-    rb_raise(cMysql2Error, "write_timeout must be a positive integer, you passed %ld", sec);
+  if(!NIL_P(value)) {
+    connect_timeout = NUM2INT(value);
+    if(0 == connect_timeout) return value;
+
+    /* set default connection timeout behavior */
+    if (mysql_options(wrapper->client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout)) {
+      /* TODO: warning - unable to set connection timeout */
+      rb_warn("%s\n", mysql_error(wrapper->client));
+    }
   }
-  return _mysql_client_options(self, MYSQL_OPT_WRITE_TIMEOUT, value);
+  return value;
 }
 
 static VALUE set_charset_name(VALUE self, VALUE value) {
-  char *charset_name;
+  char * charset_name;
 #ifdef HAVE_RUBY_ENCODING_H
-  size_t charset_name_len;
-  const struct mysql2_mysql_enc_name_to_rb_map *mysql2rb;
-  rb_encoding *enc;
-  VALUE rb_enc;
+  VALUE new_encoding;
 #endif
   GET_CLIENT(self);
 
-  charset_name = RSTRING_PTR(value);
-
 #ifdef HAVE_RUBY_ENCODING_H
-  charset_name_len = RSTRING_LEN(value);
-  mysql2rb = mysql2_mysql_enc_name_to_rb(charset_name, charset_name_len);
-  if (mysql2rb == NULL || mysql2rb->rb_name == NULL) {
+  new_encoding = rb_funcall(cMysql2Client, intern_encoding_from_charset, 1, value);
+  if (new_encoding == Qnil) {
     VALUE inspect = rb_inspect(value);
     rb_raise(cMysql2Error, "Unsupported charset: '%s'", RSTRING_PTR(inspect));
   } else {
-    enc = rb_enc_find(mysql2rb->rb_name);
-    rb_enc = rb_enc_from_encoding(enc);
-    wrapper->encoding = rb_enc;
+    if (wrapper->encoding == Qnil) {
+      wrapper->encoding = new_encoding;
+    }
   }
 #endif
 
+  charset_name = StringValuePtr(value);
+
   if (mysql_options(wrapper->client, MYSQL_SET_CHARSET_NAME, charset_name)) {
     /* TODO: warning - unable to set charset */
     rb_warn("%s\n", mysql_error(wrapper->client));
@@ -1182,73 +648,48 @@ static VALUE set_charset_name(VALUE self, VALUE value) {
 static VALUE set_ssl_options(VALUE self, VALUE key, VALUE cert, VALUE ca, VALUE capath, VALUE cipher) {
   GET_CLIENT(self);
 
-  mysql_ssl_set(wrapper->client,
-      NIL_P(key) ? NULL : StringValuePtr(key),
-      NIL_P(cert) ? NULL : StringValuePtr(cert),
-      NIL_P(ca) ? NULL : StringValuePtr(ca),
-      NIL_P(capath) ? NULL : StringValuePtr(capath),
-      NIL_P(cipher) ? NULL : StringValuePtr(cipher));
+  if(!NIL_P(ca) || !NIL_P(key)) {
+    mysql_ssl_set(wrapper->client,
+        NIL_P(key) ? NULL : StringValuePtr(key),
+        NIL_P(cert) ? NULL : StringValuePtr(cert),
+        NIL_P(ca) ? NULL : StringValuePtr(ca),
+        NIL_P(capath) ? NULL : StringValuePtr(capath),
+        NIL_P(cipher) ? NULL : StringValuePtr(cipher));
+  }
 
   return self;
 }
 
-static VALUE set_secure_auth(VALUE self, VALUE value) {
-  return _mysql_client_options(self, MYSQL_SECURE_AUTH, value);
-}
-
-static VALUE set_read_default_file(VALUE self, VALUE value) {
-  return _mysql_client_options(self, MYSQL_READ_DEFAULT_FILE, value);
-}
-
-static VALUE set_read_default_group(VALUE self, VALUE value) {
-  return _mysql_client_options(self, MYSQL_READ_DEFAULT_GROUP, value);
-}
-
-static VALUE set_init_command(VALUE self, VALUE value) {
-  return _mysql_client_options(self, MYSQL_INIT_COMMAND, value);
-}
-
-static VALUE initialize_ext(VALUE self) {
+static VALUE init_connection(VALUE self) {
   GET_CLIENT(self);
 
-  if ((VALUE)rb_thread_call_without_gvl(nogvl_init, wrapper, RUBY_UBF_IO, 0) == Qfalse) {
+  if (rb_thread_blocking_region(nogvl_init, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
     /* TODO: warning - not enough memory? */
     return rb_raise_mysql2_error(wrapper);
   }
 
-  wrapper->initialized = 1;
+  wrapper->closed = 0;
   return self;
 }
 
 void init_mysql2_client() {
-  /* verify the libmysql we're about to use was the version we were built against
-     https://github.com/luislavena/mysql-gem/commit/a600a9c459597da0712f70f43736e24b484f8a99 */
+  // verify the libmysql we're about to use was the version we were built against
+  // https://github.com/luislavena/mysql-gem/commit/a600a9c459597da0712f70f43736e24b484f8a99
   int i;
   int dots = 0;
   const char *lib = mysql_get_client_info();
-
-  for (i = 0; lib[i] != 0 && MYSQL_LINK_VERSION[i] != 0; i++) {
+  for (i = 0; lib[i] != 0 && MYSQL_SERVER_VERSION[i] != 0; i++) {
     if (lib[i] == '.') {
       dots++;
-              /* we only compare MAJOR and MINOR */
+              // we only compare MAJOR and MINOR
       if (dots == 2) break;
     }
-    if (lib[i] != MYSQL_LINK_VERSION[i]) {
-      rb_raise(rb_eRuntimeError, "Incorrect MySQL client library version! This gem was compiled for %s but the client library is %s.", MYSQL_LINK_VERSION, lib);
+    if (lib[i] != MYSQL_SERVER_VERSION[i]) {
+      rb_raise(rb_eRuntimeError, "Incorrect MySQL client library version! This gem was compiled for %s but the client library is %s.", MYSQL_SERVER_VERSION, lib);
       return;
     }
   }
 
-  /* Initializing mysql library, so different threads could call Client.new */
-  /* without race condition in the library */
-  if (mysql_library_init(0, NULL, NULL) != 0) {
-    rb_raise(rb_eRuntimeError, "Could not initialize MySQL client library");
-    return;
-  }
-
-#if 0
-  mMysql2      = rb_define_module("Mysql2"); Teach RDoc about Mysql2 constant.
-#endif
   cMysql2Client = rb_define_class_under(mMysql2, "Client", rb_cObject);
 
   rb_define_alloc_func(cMysql2Client, allocate);
@@ -1257,7 +698,6 @@ void init_mysql2_client() {
 
   rb_define_method(cMysql2Client, "close", rb_mysql_client_close, 0);
   rb_define_method(cMysql2Client, "query", rb_mysql_client_query, -1);
-  rb_define_method(cMysql2Client, "abandon_results!", rb_mysql_client_abandon_results, 0);
   rb_define_method(cMysql2Client, "escape", rb_mysql_client_real_escape, 1);
   rb_define_method(cMysql2Client, "info", rb_mysql_client_info, 0);
   rb_define_method(cMysql2Client, "server_info", rb_mysql_client_server_info, 0);
@@ -1267,150 +707,133 @@ void init_mysql2_client() {
   rb_define_method(cMysql2Client, "affected_rows", rb_mysql_client_affected_rows, 0);
   rb_define_method(cMysql2Client, "thread_id", rb_mysql_client_thread_id, 0);
   rb_define_method(cMysql2Client, "ping", rb_mysql_client_ping, 0);
-  rb_define_method(cMysql2Client, "select_db", rb_mysql_client_select_db, 1);
-  rb_define_method(cMysql2Client, "more_results?", rb_mysql_client_more_results, 0);
-  rb_define_method(cMysql2Client, "next_result", rb_mysql_client_next_result, 0);
-  rb_define_method(cMysql2Client, "store_result", rb_mysql_client_store_result, 0);
-  rb_define_method(cMysql2Client, "reconnect=", set_reconnect, 1);
-  rb_define_method(cMysql2Client, "warning_count", rb_mysql_client_warning_count, 0);
-  rb_define_method(cMysql2Client, "query_info_string", rb_mysql_info, 0);
 #ifdef HAVE_RUBY_ENCODING_H
   rb_define_method(cMysql2Client, "encoding", rb_mysql_client_encoding, 0);
 #endif
 
+  rb_define_private_method(cMysql2Client, "reconnect=", set_reconnect, 1);
   rb_define_private_method(cMysql2Client, "connect_timeout=", set_connect_timeout, 1);
-  rb_define_private_method(cMysql2Client, "read_timeout=", set_read_timeout, 1);
-  rb_define_private_method(cMysql2Client, "write_timeout=", set_write_timeout, 1);
-  rb_define_private_method(cMysql2Client, "local_infile=", set_local_infile, 1);
   rb_define_private_method(cMysql2Client, "charset_name=", set_charset_name, 1);
-  rb_define_private_method(cMysql2Client, "secure_auth=", set_secure_auth, 1);
-  rb_define_private_method(cMysql2Client, "default_file=", set_read_default_file, 1);
-  rb_define_private_method(cMysql2Client, "default_group=", set_read_default_group, 1);
-  rb_define_private_method(cMysql2Client, "init_command=", set_init_command, 1);
   rb_define_private_method(cMysql2Client, "ssl_set", set_ssl_options, 5);
-  rb_define_private_method(cMysql2Client, "initialize_ext", initialize_ext, 0);
+  rb_define_private_method(cMysql2Client, "init_connection", init_connection, 0);
   rb_define_private_method(cMysql2Client, "connect", rb_connect, 7);
 
+  intern_encoding_from_charset = rb_intern("encoding_from_charset");
+
   sym_id              = ID2SYM(rb_intern("id"));
   sym_version         = ID2SYM(rb_intern("version"));
   sym_async           = ID2SYM(rb_intern("async"));
   sym_symbolize_keys  = ID2SYM(rb_intern("symbolize_keys"));
   sym_as              = ID2SYM(rb_intern("as"));
   sym_array           = ID2SYM(rb_intern("array"));
-  sym_stream          = ID2SYM(rb_intern("stream"));
 
   intern_merge = rb_intern("merge");
-  intern_merge_bang = rb_intern("merge!");
   intern_error_number_eql = rb_intern("error_number=");
   intern_sql_state_eql = rb_intern("sql_state=");
 
 #ifdef CLIENT_LONG_PASSWORD
   rb_const_set(cMysql2Client, rb_intern("LONG_PASSWORD"),
-      LONG2NUM(CLIENT_LONG_PASSWORD));
+      INT2NUM(CLIENT_LONG_PASSWORD));
 #endif
 
 #ifdef CLIENT_FOUND_ROWS
   rb_const_set(cMysql2Client, rb_intern("FOUND_ROWS"),
-      LONG2NUM(CLIENT_FOUND_ROWS));
+      INT2NUM(CLIENT_FOUND_ROWS));
 #endif
 
 #ifdef CLIENT_LONG_FLAG
   rb_const_set(cMysql2Client, rb_intern("LONG_FLAG"),
-      LONG2NUM(CLIENT_LONG_FLAG));
+      INT2NUM(CLIENT_LONG_FLAG));
 #endif
 
 #ifdef CLIENT_CONNECT_WITH_DB
   rb_const_set(cMysql2Client, rb_intern("CONNECT_WITH_DB"),
-      LONG2NUM(CLIENT_CONNECT_WITH_DB));
+      INT2NUM(CLIENT_CONNECT_WITH_DB));
 #endif
 
 #ifdef CLIENT_NO_SCHEMA
   rb_const_set(cMysql2Client, rb_intern("NO_SCHEMA"),
-      LONG2NUM(CLIENT_NO_SCHEMA));
+      INT2NUM(CLIENT_NO_SCHEMA));
 #endif
 
 #ifdef CLIENT_COMPRESS
-  rb_const_set(cMysql2Client, rb_intern("COMPRESS"), LONG2NUM(CLIENT_COMPRESS));
+  rb_const_set(cMysql2Client, rb_intern("COMPRESS"), INT2NUM(CLIENT_COMPRESS));
 #endif
 
 #ifdef CLIENT_ODBC
-  rb_const_set(cMysql2Client, rb_intern("ODBC"), LONG2NUM(CLIENT_ODBC));
+  rb_const_set(cMysql2Client, rb_intern("ODBC"), INT2NUM(CLIENT_ODBC));
 #endif
 
 #ifdef CLIENT_LOCAL_FILES
   rb_const_set(cMysql2Client, rb_intern("LOCAL_FILES"),
-      LONG2NUM(CLIENT_LOCAL_FILES));
+      INT2NUM(CLIENT_LOCAL_FILES));
 #endif
 
 #ifdef CLIENT_IGNORE_SPACE
   rb_const_set(cMysql2Client, rb_intern("IGNORE_SPACE"),
-      LONG2NUM(CLIENT_IGNORE_SPACE));
+      INT2NUM(CLIENT_IGNORE_SPACE));
 #endif
 
 #ifdef CLIENT_PROTOCOL_41
   rb_const_set(cMysql2Client, rb_intern("PROTOCOL_41"),
-      LONG2NUM(CLIENT_PROTOCOL_41));
+      INT2NUM(CLIENT_PROTOCOL_41));
 #endif
 
 #ifdef CLIENT_INTERACTIVE
   rb_const_set(cMysql2Client, rb_intern("INTERACTIVE"),
-      LONG2NUM(CLIENT_INTERACTIVE));
+      INT2NUM(CLIENT_INTERACTIVE));
 #endif
 
 #ifdef CLIENT_SSL
-  rb_const_set(cMysql2Client, rb_intern("SSL"), LONG2NUM(CLIENT_SSL));
+  rb_const_set(cMysql2Client, rb_intern("SSL"), INT2NUM(CLIENT_SSL));
 #endif
 
 #ifdef CLIENT_IGNORE_SIGPIPE
   rb_const_set(cMysql2Client, rb_intern("IGNORE_SIGPIPE"),
-      LONG2NUM(CLIENT_IGNORE_SIGPIPE));
+      INT2NUM(CLIENT_IGNORE_SIGPIPE));
 #endif
 
 #ifdef CLIENT_TRANSACTIONS
   rb_const_set(cMysql2Client, rb_intern("TRANSACTIONS"),
-      LONG2NUM(CLIENT_TRANSACTIONS));
+      INT2NUM(CLIENT_TRANSACTIONS));
 #endif
 
 #ifdef CLIENT_RESERVED
-  rb_const_set(cMysql2Client, rb_intern("RESERVED"), LONG2NUM(CLIENT_RESERVED));
+  rb_const_set(cMysql2Client, rb_intern("RESERVED"), INT2NUM(CLIENT_RESERVED));
 #endif
 
 #ifdef CLIENT_SECURE_CONNECTION
   rb_const_set(cMysql2Client, rb_intern("SECURE_CONNECTION"),
-      LONG2NUM(CLIENT_SECURE_CONNECTION));
-#else
-  /* HACK because MySQL5.7 no longer defines this constant,
-   * but we're using it in our default connection flags. */
-  rb_const_set(cMysql2Client, rb_intern("SECURE_CONNECTION"), LONG2NUM(0));
+      INT2NUM(CLIENT_SECURE_CONNECTION));
 #endif
 
 #ifdef CLIENT_MULTI_STATEMENTS
   rb_const_set(cMysql2Client, rb_intern("MULTI_STATEMENTS"),
-      LONG2NUM(CLIENT_MULTI_STATEMENTS));
+      INT2NUM(CLIENT_MULTI_STATEMENTS));
 #endif
 
 #ifdef CLIENT_PS_MULTI_RESULTS
   rb_const_set(cMysql2Client, rb_intern("PS_MULTI_RESULTS"),
-      LONG2NUM(CLIENT_PS_MULTI_RESULTS));
+      INT2NUM(CLIENT_PS_MULTI_RESULTS));
 #endif
 
 #ifdef CLIENT_SSL_VERIFY_SERVER_CERT
   rb_const_set(cMysql2Client, rb_intern("SSL_VERIFY_SERVER_CERT"),
-      LONG2NUM(CLIENT_SSL_VERIFY_SERVER_CERT));
+      INT2NUM(CLIENT_SSL_VERIFY_SERVER_CERT));
 #endif
 
 #ifdef CLIENT_REMEMBER_OPTIONS
   rb_const_set(cMysql2Client, rb_intern("REMEMBER_OPTIONS"),
-      LONG2NUM(CLIENT_REMEMBER_OPTIONS));
+      INT2NUM(CLIENT_REMEMBER_OPTIONS));
 #endif
 
 #ifdef CLIENT_ALL_FLAGS
   rb_const_set(cMysql2Client, rb_intern("ALL_FLAGS"),
-      LONG2NUM(CLIENT_ALL_FLAGS));
+      INT2NUM(CLIENT_ALL_FLAGS));
 #endif
 
 #ifdef CLIENT_BASIC_FLAGS
   rb_const_set(cMysql2Client, rb_intern("BASIC_FLAGS"),
-      LONG2NUM(CLIENT_BASIC_FLAGS));
+      INT2NUM(CLIENT_BASIC_FLAGS));
 #endif
 }