mysql2 0.2.6-x86-mingw32 → 0.2.16-x86-mingw32

data/benchmark/escape.rb

@@ -10,24 +10,21 @@ require 'do_mysql'
 def run_escape_benchmarks(str, number_of = 1000)
   Benchmark.bmbm do |x|
     mysql = Mysql.new("localhost", "root")
-    x.report do
-      puts "Mysql #{str.inspect}"
+    x.report "Mysql #{str.inspect}" do
       number_of.times do
         mysql.quote str
       end
     end
 
     mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")
-    x.report do
-      puts "Mysql2 #{str.inspect}"
+    x.report "Mysql2 #{str.inspect}" do
       number_of.times do
         mysql2.escape str
       end
     end
 
     do_mysql = DataObjects::Connection.new("mysql://localhost/test")
-    x.report do
-      puts "do_mysql #{str.inspect}"
+    x.report "do_mysql #{str.inspect}" do
       number_of.times do
         do_mysql.quote_string str
       end

data/benchmark/query_with_mysql_casting.rb

@@ -42,8 +42,7 @@ end
 Benchmark.bmbm do |x|
   mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")
   mysql2.query "USE #{database}"
-  x.report do
-    puts "Mysql2"
+  x.report "Mysql2" do
     number_of.times do
       mysql2_result = mysql2.query sql, :symbolize_keys => true
       mysql2_result.each do |res|
@@ -54,8 +53,7 @@ Benchmark.bmbm do |x|
 
   mysql = Mysql.new("localhost", "root")
   mysql.query "USE #{database}"
-  x.report do
-    puts "Mysql"
+  x.report "Mysql" do
     number_of.times do
       mysql_result = mysql.query sql
       fields = mysql_result.fetch_fields
@@ -71,8 +69,7 @@ Benchmark.bmbm do |x|
 
   do_mysql = DataObjects::Connection.new("mysql://localhost/#{database}")
   command = do_mysql.create_command sql
-  x.report do
-    puts "do_mysql"
+  x.report "do_mysql" do
     number_of.times do
       do_result = command.execute_reader
       do_result.each do |res|

data/benchmark/query_without_mysql_casting.rb

@@ -14,10 +14,18 @@ sql = "SELECT * FROM mysql2_test LIMIT 100"
 Benchmark.bmbm do |x|
   mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")
   mysql2.query "USE #{database}"
-  x.report do
-    puts "Mysql2"
+  x.report "Mysql2 (cast: true)" do
     number_of.times do
-      mysql2_result = mysql2.query sql, :symbolize_keys => true
+      mysql2_result = mysql2.query sql, :symbolize_keys => true, :cast => true
+      mysql2_result.each do |res|
+        # puts res.inspect
+      end
+    end
+  end
+
+  x.report "Mysql2 (cast: false)" do
+    number_of.times do
+      mysql2_result = mysql2.query sql, :symbolize_keys => true, :cast => false
       mysql2_result.each do |res|
         # puts res.inspect
       end
@@ -26,8 +34,7 @@ Benchmark.bmbm do |x|
 
   mysql = Mysql.new("localhost", "root")
   mysql.query "USE #{database}"
-  x.report do
-    puts "Mysql"
+  x.report "Mysql" do
     number_of.times do
       mysql_result = mysql.query sql
       mysql_result.each_hash do |res|
@@ -38,8 +45,7 @@ Benchmark.bmbm do |x|
 
   do_mysql = DataObjects::Connection.new("mysql://localhost/#{database}")
   command = DataObjects::Mysql::Command.new do_mysql, sql
-  x.report do
-    puts "do_mysql"
+  x.report "do_mysql" do
     number_of.times do
       do_result = command.execute_reader
       do_result.each do |res|

data/benchmark/sequel.rb

@@ -3,6 +3,7 @@ $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 
 require 'rubygems'
 require 'benchmark'
+require 'mysql2'
 require 'sequel'
 require 'sequel/adapters/do'
 
@@ -16,22 +17,19 @@ class MysqlModel < Sequel::Model(Sequel.connect(mysql_opts)[:mysql2_test]); end
 class DOMysqlModel < Sequel::Model(Sequel.connect(do_mysql_opts)[:mysql2_test]); end
 
 Benchmark.bmbm do |x|
-  x.report do
-    puts "Mysql2"
+  x.report "Mysql2" do
     number_of.times do
       Mysql2Model.limit(1000).all
     end
   end
 
-  x.report do
-    puts "do:mysql"
+  x.report "do:mysql" do
     number_of.times do
       DOMysqlModel.limit(1000).all
     end
   end
 
-  x.report do
-    puts "Mysql"
+  x.report "Mysql" do
     number_of.times do
       MysqlModel.limit(1000).all
     end

data/benchmark/setup_db.rb

@@ -76,6 +76,8 @@ end
 
 puts "Creating #{num} records"
 num.times do |n|
+  five_words = Faker::Lorem.words(rand(5))
+  twenty5_paragraphs = Faker::Lorem.paragraphs(rand(25))
   insert_record(
     :bit_test => 1,
     :tiny_int_test => rand(128),
@@ -93,23 +95,25 @@ num.times do |n|
     :timestamp_test => '2010-4-4 11:44:00',
     :time_test => '11:44:00',
     :year_test => Time.now.year,
-    :char_test => Faker::Lorem.words(rand(5)),
-    :varchar_test => Faker::Lorem.words(rand(5)),
-    :binary_test => Faker::Lorem.words(rand(5)),
-    :varbinary_test => Faker::Lorem.words(rand(5)),
-    :tiny_blob_test => Faker::Lorem.words(rand(5)),
+    :char_test => five_words,
+    :varchar_test => five_words,
+    :binary_test => five_words,
+    :varbinary_test => five_words,
+    :tiny_blob_test => five_words,
     :tiny_text_test => Faker::Lorem.paragraph(rand(5)),
-    :blob_test => Faker::Lorem.paragraphs(rand(25)),
-    :text_test => Faker::Lorem.paragraphs(rand(25)),
-    :medium_blob_test => Faker::Lorem.paragraphs(rand(25)),
-    :medium_text_test => Faker::Lorem.paragraphs(rand(25)),
-    :long_blob_test => Faker::Lorem.paragraphs(rand(25)),
-    :long_text_test => Faker::Lorem.paragraphs(rand(25)),
+    :blob_test => twenty5_paragraphs,
+    :text_test => twenty5_paragraphs,
+    :medium_blob_test => twenty5_paragraphs,
+    :medium_text_test => twenty5_paragraphs,
+    :long_blob_test => twenty5_paragraphs,
+    :long_text_test => twenty5_paragraphs,
     :enum_test => ['val1', 'val2'].rand,
     :set_test => ['val1', 'val2', 'val1,val2'].rand
   )
-  $stdout.putc '.'
-  $stdout.flush
+  if n % 100 == 0
+    $stdout.putc '.'
+    $stdout.flush
+  end
 end
 puts
 puts "Done"

data/benchmark/threaded.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'benchmark'
+require 'active_record'
+
+mysql2_opts = {
+  :adapter => 'mysql2',
+  :database => 'test',
+  :pool => 25
+}
+ActiveRecord::Base.establish_connection(mysql2_opts)
+x = Benchmark.realtime do
+  threads = []
+  25.times do
+    threads << Thread.new { ActiveRecord::Base.connection.execute("select sleep(1)") }
+  end
+  threads.each {|t| t.join }
+end
+puts x
+
+mysql2_opts = {
+  :adapter => 'mysql',
+  :database => 'test',
+  :pool => 25
+}
+ActiveRecord::Base.establish_connection(mysql2_opts)
+x = Benchmark.realtime do
+  threads = []
+  25.times do
+    threads << Thread.new { ActiveRecord::Base.connection.execute("select sleep(1)") }
+  end
+  threads.each {|t| t.join }
+end
+puts x
+
+# these results are similar on 1.8.7, 1.9.2 and rbx-head
+#
+# $ bundle exec ruby benchmarks/threaded.rb
+# 1.0774750709533691
+#
+# and using the mysql gem
+# 25.099437952041626

data/ext/mysql2/client.c

@@ -1,17 +1,20 @@
 #include <mysql2_ext.h>
 #include <client.h>
 #include <errno.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#endif
+#include "wait_for_single_fd.h"
 
 VALUE cMysql2Client;
 extern VALUE mMysql2, cMysql2Error;
 static VALUE intern_encoding_from_charset;
-static ID sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array;
+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;
 
 #define REQUIRE_OPEN_DB(wrapper) \
-  if(wrapper->closed) { \
+  if(!wrapper->reconnect_enabled && wrapper->closed) { \
     rb_raise(cMysql2Error, "closed MySQL connection"); \
-    return Qnil; \
   }
 
 #define MARK_CONN_INACTIVE(conn) \
@@ -43,6 +46,7 @@ struct nogvl_connect_args {
 struct nogvl_send_query_args {
   MYSQL *mysql;
   VALUE sql;
+  mysql_client_wrapper *wrapper;
 };
 
 /*
@@ -74,10 +78,24 @@ static void rb_mysql_client_mark(void * wrapper) {
   }
 }
 
-static VALUE rb_raise_mysql2_error(MYSQL *client) {
-  VALUE e = rb_exc_new2(cMysql2Error, mysql_error(client));
-  rb_funcall(e, intern_error_number_eql, 1, INT2NUM(mysql_errno(client)));
-  rb_funcall(e, intern_sql_state_eql, 1, rb_tainted_str_new2(mysql_sqlstate(client)));
+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));
+#ifdef HAVE_RUBY_ENCODING_H
+  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
+
+  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;
 }
@@ -105,10 +123,14 @@ static VALUE nogvl_connect(void *ptr) {
 }
 
 static VALUE nogvl_close(void *ptr) {
-  mysql_client_wrapper *wrapper = ptr;
+  mysql_client_wrapper *wrapper;
+#ifndef _WIN32
+  int flags;
+#endif
+  wrapper = ptr;
   if (!wrapper->closed) {
     wrapper->closed = 1;
-
+    wrapper->active = 0;
     /*
      * 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
@@ -119,12 +141,9 @@ static VALUE nogvl_close(void *ptr) {
      * so ignore any potential fcntl errors since they don't matter
      */
 #ifndef _WIN32
-    int flags = fcntl(wrapper->client->net.fd, F_GETFL);
+    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 = 1;
-    ioctlsocket(wrapper->client->net.fd, FIONBIO, &iMode);
 #endif
 
     mysql_close(wrapper->client);
@@ -139,7 +158,7 @@ static void rb_mysql_client_free(void * ptr) {
 
   nogvl_close(wrapper);
 
-  xfree(ptr);
+  free(ptr);
 }
 
 static VALUE allocate(VALUE klass) {
@@ -148,11 +167,37 @@ static VALUE allocate(VALUE klass) {
   obj = Data_Make_Struct(klass, mysql_client_wrapper, rb_mysql_client_mark, rb_mysql_client_free, wrapper);
   wrapper->encoding = Qnil;
   wrapper->active = 0;
+  wrapper->reconnect_enabled = 0;
   wrapper->closed = 1;
   wrapper->client = (MYSQL*)malloc(sizeof(MYSQL));
   return obj;
 }
 
+static VALUE rb_mysql_client_escape(RB_MYSQL_UNUSED VALUE klass, VALUE str) {
+  unsigned char *newStr;
+  VALUE rb_str;
+  unsigned long newLen, oldLen;
+
+  Check_Type(str, T_STRING);
+
+  oldLen = RSTRING_LEN(str);
+  newStr = malloc(oldLen*2+1);
+
+  newLen = mysql_escape_string((char *)newStr, StringValuePtr(str), oldLen);
+  if (newLen == oldLen) {
+    // no need to return a new ruby string if nothing changed
+    free(newStr);
+    return str;
+  } else {
+    rb_str = rb_str_new((const char*)newStr, newLen);
+#ifdef HAVE_RUBY_ENCODING_H
+    rb_enc_copy(rb_str, str);
+#endif
+    free(newStr);
+    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;
   GET_CLIENT(self);
@@ -168,7 +213,7 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
 
   if (rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0) == Qfalse) {
     // unable to connect
-    return rb_raise_mysql2_error(wrapper->client);
+    return rb_raise_mysql2_error(wrapper);
   }
 
   return self;
@@ -206,6 +251,17 @@ static VALUE nogvl_send_query(void *ptr) {
   return 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 (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);
+  }
+  return Qnil;
+}
+
 /*
  * even though we did rb_thread_select before calling this, a large
  * response can overflow the socket buffers and cause us to eventually
@@ -220,63 +276,161 @@ static VALUE nogvl_read_query_result(void *ptr) {
 
 /* mysql_store_result may (unlikely) read rows off the socket */
 static VALUE nogvl_store_result(void *ptr) {
-  MYSQL * client = ptr;
-  return (VALUE)mysql_store_result(client);
+  mysql_client_wrapper *wrapper;
+  MYSQL_RES *result;
+
+  wrapper = (mysql_client_wrapper *)ptr;
+  result = mysql_store_result(wrapper->client);
+
+  // once our result is stored off, this connection is
+  // ready for another command to be issued
+  wrapper->active = 0;
+
+  return (VALUE)result;
 }
 
 static VALUE rb_mysql_client_async_result(VALUE self) {
   MYSQL_RES * result;
+  VALUE resultObj;
+#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 (!wrapper->active)
+    return Qnil;
+
   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->client);
+    return rb_raise_mysql2_error(wrapper);
   }
 
-  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);
+  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
 
   if (result == NULL) {
     if (mysql_field_count(wrapper->client) != 0) {
-      rb_raise_mysql2_error(wrapper->client);
+      rb_raise_mysql2_error(wrapper);
     }
     return Qnil;
   }
 
-  VALUE resultObj = rb_mysql_result_to_obj(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
-  mysql2_result_wrapper * result_wrapper;
   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) {
+  GET_CLIENT(self);
+
+  wrapper->closed = 1;
+  wrapper->active = 0;
+
+  // manually close the socket for read/write
+  // this feels dirty, but is there another way?
+  shutdown(wrapper->client->net.fd, 2);
+
+  rb_exc_raise(error);
+
+  return Qnil;
+}
+
+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;
+
+  async_args = (struct async_query_args *)args;
+  read_timeout = rb_iv_get(async_args->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
+    if (sec >= 0) {
+      tvp->tv_sec = sec;
+    } else {
+      rb_raise(cMysql2Error, "read_timeout must be a positive integer, you passed %ld", sec);
+    }
+    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 (wrapper->active) {
+    // 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_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+    mysql_free_result(result);
+
+    wrapper->active = 0;
+  }
+
+  return Qnil;
+}
+#endif
+
 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;
-  fd_set fdset;
-  int fd, retval;
   int async = 0;
   VALUE opts, defaults;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *conn_enc;
+#endif
   GET_CLIENT(self);
 
   REQUIRE_OPEN_DB(wrapper);
   args.mysql = wrapper->client;
 
-  // 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");
-  }
 
   defaults = rb_iv_get(self, "@query_options");
   if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) {
@@ -290,85 +444,96 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
     opts = defaults;
   }
 
+  Check_Type(args.sql, T_STRING);
 #ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
+  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->client);
+  // 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");
   }
 
+  args.wrapper = wrapper;
+
+#ifndef _WIN32
+  rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0);
+
   if (!async) {
-    // the below code is largely from do_mysql
-    // http://github.com/datamapper/do
-    fd = wrapper->client->net.fd;
-    for(;;) {
-      FD_ZERO(&fdset);
-      FD_SET(fd, &fdset);
-
-      retval = rb_thread_select(fd + 1, &fdset, NULL, NULL, NULL);
-
-      if (retval < 0) {
-        rb_sys_fail(0);
-      }
-
-      if (retval > 0) {
-        break;
-      }
-    }
+    async_args.fd = wrapper->client->net.fd;
+    async_args.self = self;
 
-    VALUE result = rb_mysql_client_async_result(self);
+    rb_rescue2(do_query, (VALUE)&async_args, disconnect_and_raise, self, rb_eException, (VALUE)0);
 
-    return result;
+    return rb_mysql_client_async_result(self);
   } 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
 }
 
-static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
-  VALUE newStr;
+static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
+  unsigned char *newStr;
+  VALUE rb_str;
   unsigned long newLen, oldLen;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+  rb_encoding *conn_enc;
+#endif
   GET_CLIENT(self);
 
   REQUIRE_OPEN_DB(wrapper);
   Check_Type(str, T_STRING);
 #ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *default_internal_enc = rb_default_internal_encoding();
-  rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
+  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
   str = rb_str_export_to_enc(str, conn_enc);
 #endif
 
   oldLen = RSTRING_LEN(str);
-  newStr = rb_str_new(0, oldLen*2+1);
+  newStr = malloc(oldLen*2+1);
 
-  newLen = mysql_real_escape_string(wrapper->client, RSTRING_PTR(newStr), StringValuePtr(str), oldLen);
+  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
+    free(newStr);
     return str;
   } else {
-    rb_str_resize(newStr, newLen);
+    rb_str = rb_str_new((const char*)newStr, newLen);
 #ifdef HAVE_RUBY_ENCODING_H
-    rb_enc_associate(newStr, conn_enc);
+    rb_enc_associate(rb_str, conn_enc);
     if (default_internal_enc) {
-      newStr = rb_str_export_to_enc(newStr, default_internal_enc);
+      rb_str = rb_str_export_to_enc(rb_str, default_internal_enc);
     }
 #endif
-    return newStr;
+    free(newStr);
+    return rb_str;
   }
 }
 
 static VALUE rb_mysql_client_info(VALUE self) {
-  VALUE version = rb_hash_new(), client_info;
+  VALUE version, client_info;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+  rb_encoding *conn_enc;
+#endif
   GET_CLIENT(self);
+  version = rb_hash_new();
 
 #ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *default_internal_enc = rb_default_internal_encoding();
-  rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
+  default_internal_enc = rb_default_internal_encoding();
+  conn_enc = rb_to_encoding(wrapper->encoding);
 #endif
 
   rb_hash_aset(version, sym_id, LONG2NUM(mysql_get_client_version()));
@@ -385,12 +550,16 @@ static VALUE rb_mysql_client_info(VALUE self) {
 
 static VALUE rb_mysql_client_server_info(VALUE self) {
   VALUE version, server_info;
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+  rb_encoding *conn_enc;
+#endif
   GET_CLIENT(self);
 
   REQUIRE_OPEN_DB(wrapper);
 #ifdef HAVE_RUBY_ENCODING_H
-  rb_encoding *default_internal_enc = rb_default_internal_encoding();
-  rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
+  default_internal_enc = rb_default_internal_encoding();
+  conn_enc = rb_to_encoding(wrapper->encoding);
 #endif
 
   version = rb_hash_new();
@@ -408,8 +577,13 @@ static VALUE rb_mysql_client_server_info(VALUE self) {
 
 static VALUE rb_mysql_client_socket(VALUE self) {
   GET_CLIENT(self);
+#ifndef _WIN32
   REQUIRE_OPEN_DB(wrapper);
-  return INT2NUM(wrapper->client->net.fd);
+  int fd_set_fd = wrapper->client->net.fd;
+  return INT2NUM(fd_set_fd);
+#else
+  rb_raise(cMysql2Error, "Raw access to the mysql file descriptor isn't supported on Windows");
+#endif
 }
 
 static VALUE rb_mysql_client_last_id(VALUE self) {
@@ -419,17 +593,49 @@ static VALUE rb_mysql_client_last_id(VALUE self) {
 }
 
 static VALUE rb_mysql_client_affected_rows(VALUE self) {
-  GET_CLIENT(self);
   my_ulonglong retVal;
+  GET_CLIENT(self);
 
   REQUIRE_OPEN_DB(wrapper);
   retVal = mysql_affected_rows(wrapper->client);
   if (retVal == (my_ulonglong)-1) {
-    rb_raise_mysql2_error(wrapper->client);
+    rb_raise_mysql2_error(wrapper);
   }
   return ULL2NUM(retVal);
 }
 
+static VALUE rb_mysql_client_thread_id(VALUE self) {
+  unsigned long retVal;
+  GET_CLIENT(self);
+
+  REQUIRE_OPEN_DB(wrapper);
+  retVal = mysql_thread_id(wrapper->client);
+  return ULL2NUM(retVal);
+}
+
+static VALUE nogvl_ping(void *ptr) {
+  MYSQL *client = ptr;
+
+  return mysql_ping(client) == 0 ? Qtrue : Qfalse;
+}
+
+static VALUE rb_mysql_client_ping(VALUE self) {
+  GET_CLIENT(self);
+
+  if (wrapper->closed) {
+    return Qfalse;
+  } else {
+    return rb_thread_blocking_region(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
+  }
+}
+
+#ifdef HAVE_RUBY_ENCODING_H
+static VALUE rb_mysql_client_encoding(VALUE self) {
+  GET_CLIENT(self);
+  return wrapper->encoding;
+}
+#endif
+
 static VALUE set_reconnect(VALUE self, VALUE value) {
   my_bool reconnect;
   GET_CLIENT(self);
@@ -437,6 +643,7 @@ static VALUE set_reconnect(VALUE self, VALUE value) {
   if(!NIL_P(value)) {
     reconnect = value == Qfalse ? 0 : 1;
 
+    wrapper->reconnect_enabled = reconnect;
     /* set default reconnect behavior */
     if (mysql_options(wrapper->client, MYSQL_OPT_RECONNECT, &reconnect)) {
       /* TODO: warning - unable to set reconnect behavior */
@@ -465,13 +672,16 @@ static VALUE set_connect_timeout(VALUE self, VALUE value) {
 
 static VALUE set_charset_name(VALUE self, VALUE value) {
   char * charset_name;
+#ifdef HAVE_RUBY_ENCODING_H
+  VALUE new_encoding;
+#endif
   GET_CLIENT(self);
 
 #ifdef HAVE_RUBY_ENCODING_H
-  VALUE new_encoding;
   new_encoding = rb_funcall(cMysql2Client, intern_encoding_from_charset, 1, value);
   if (new_encoding == Qnil) {
-    rb_raise(cMysql2Error, "Unsupported charset: '%s'", RSTRING_PTR(value));
+    VALUE inspect = rb_inspect(value);
+    rb_raise(cMysql2Error, "Unsupported charset: '%s'", RSTRING_PTR(inspect));
   } else {
     if (wrapper->encoding == Qnil) {
       wrapper->encoding = new_encoding;
@@ -509,7 +719,7 @@ static VALUE init_connection(VALUE self) {
 
   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->client);
+    return rb_raise_mysql2_error(wrapper);
   }
 
   wrapper->closed = 0;
@@ -517,19 +727,43 @@ static VALUE init_connection(VALUE 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
+  int i;
+  int dots = 0;
+  const char *lib = mysql_get_client_info();
+  for (i = 0; lib[i] != 0 && MYSQL_SERVER_VERSION[i] != 0; i++) {
+    if (lib[i] == '.') {
+      dots++;
+              // we only compare MAJOR and MINOR
+      if (dots == 2) break;
+    }
+    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;
+    }
+  }
+
   cMysql2Client = rb_define_class_under(mMysql2, "Client", rb_cObject);
 
   rb_define_alloc_func(cMysql2Client, allocate);
 
+  rb_define_singleton_method(cMysql2Client, "escape", rb_mysql_client_escape, 1);
+
   rb_define_method(cMysql2Client, "close", rb_mysql_client_close, 0);
   rb_define_method(cMysql2Client, "query", rb_mysql_client_query, -1);
-  rb_define_method(cMysql2Client, "escape", rb_mysql_client_escape, 1);
+  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);
   rb_define_method(cMysql2Client, "socket", rb_mysql_client_socket, 0);
   rb_define_method(cMysql2Client, "async_result", rb_mysql_client_async_result, 0);
   rb_define_method(cMysql2Client, "last_id", rb_mysql_client_last_id, 0);
   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);
+#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);