mysql2 0.2.6 → 0.2.7

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@mysql2 --create

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.2.7 (March 28th, 2011)
+* various fixes for em_mysql2 and fiber usage
+* use our own Mysql2IndexDefinition class for better compatibility across ActiveRecord versions
+* ensure the query is a string earlier in the Mysql2::Client#query codepath for 1.9
+* only set binary ruby encoding on fields that have a binary flag *and* encoding set
+* a few various optimizations
+* add support for :read_timeout to be set on a connection
+* Fix to install with MariDB on Windows
+* add fibered em connection without activerecord
+* fix some 1.9.3 compilation warnings
+* add LD_RUN_PATH when using hard coded mysql paths - this should help users with MySQL installed in non-standard locations
+* for windows support, duplicate the socket from libmysql and create a temporary CRT fd
+* fix for handling years before 1970 on Windows
+* fixes to the Fiber adapter
+* set wait_timeout maximum on Windows to 2147483
+* update supported range for Time objects
+* upon being required, make sure the libmysql we're using is the one we were built against
+* add Mysql2::Client#thread_id
+* add Mysql2::Client#ping
+* switch connection check in AR adapter to use Mysql2::Client#ping for efficiency
+* prefer linking against thread-safe version of libmysqlclient
+* define RSTRING_NOT_MODIFIED for an awesome rbx speed boost
+* expose Mysql2::Client#encoding in 1.9, make sure we set the error message and sqlstate encodings accordingly
+* do not segfault when raising for invalid charset (found in 1.9.3dev)
+
 ## 0.2.6 (October 19th, 2010)
 * version bump since the 0.2.5 win32 binary gems were broken
 

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Brian Lopez - http://github.com/brianmario
+Copyright (c) 2010-2011 Brian Lopez - http://github.com/brianmario
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -146,7 +146,7 @@ This would be helpful if you wanted to iterate over the results in a streaming m
 
 == ActiveRecord
 
-To use the ActiveRecord driver, all you should need to do is have this gem installed and set the adapter in your database.yml to "mysql2".
+To use the ActiveRecord driver (with our without rails), all you should need to do is have this gem installed and set the adapter in your database.yml to "mysql2".
 That was easy right? :)
 
 == Asynchronous ActiveRecord
@@ -232,6 +232,14 @@ then iterating over every row using an #each like method yielding a block:
   Mysql
    7.500000   0.210000   7.710000 (  8.065871)
 
+== Development
+
+To run the tests, you can use RVM and Bundler to create a pristine environment for mysql2 development/hacking.
+Use 'bundle install' to install the necessary development and testing gems:
+
+    bundle install
+    rake
+
 == Special Thanks
 
 * Eric Wong - for the contribution (and the informative explanations) of some thread-safety, non-blocking I/O and cleanup patches. You rock dude

data/benchmark/active_record.rb

@@ -27,9 +27,8 @@ class MysqlModel < ActiveRecord::Base
 end
 
 Benchmark.bmbm do |x|
-  x.report do
+  x.report "Mysql2" do
     Mysql2Model.establish_connection(mysql2_opts)
-    puts "Mysql2"
     number_of.times do
       Mysql2Model.all(:limit => 1000).each{ |r|
         r.attributes.keys.each{ |k|
@@ -39,9 +38,8 @@ Benchmark.bmbm do |x|
     end
   end
 
-  x.report do
+  x.report "Mysql" do
     MysqlModel.establish_connection(mysql_opts)
-    puts "Mysql"
     number_of.times do
       MysqlModel.all(:limit => 1000).each{ |r|
         r.attributes.keys.each{ |k|

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,8 +14,7 @@ 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" do
     number_of.times do
       mysql2_result = mysql2.query sql, :symbolize_keys => true
       mysql2_result.each do |res|
@@ -26,8 +25,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 +36,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/ext/mysql2/client.c

@@ -5,13 +5,12 @@
 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) { \
     rb_raise(cMysql2Error, "closed MySQL connection"); \
-    return Qnil; \
   }
 
 #define MARK_CONN_INACTIVE(conn) \
@@ -74,10 +73,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,7 +118,11 @@ 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;
 
@@ -119,16 +136,17 @@ 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;
+    u_long iMode;
+    iMode = 1;
     ioctlsocket(wrapper->client->net.fd, FIONBIO, &iMode);
 #endif
 
     mysql_close(wrapper->client);
-    free(wrapper->client);
+    xfree(wrapper->client);
   }
 
   return Qnil;
@@ -149,7 +167,7 @@ static VALUE allocate(VALUE klass) {
   wrapper->encoding = Qnil;
   wrapper->active = 0;
   wrapper->closed = 1;
-  wrapper->client = (MYSQL*)malloc(sizeof(MYSQL));
+  wrapper->client = (MYSQL*)xmalloc(sizeof(MYSQL));
   return obj;
 }
 
@@ -168,7 +186,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;
@@ -226,13 +244,17 @@ static VALUE nogvl_store_result(void *ptr) {
 
 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);
 
   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);
@@ -242,17 +264,16 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
 
   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
@@ -264,7 +285,14 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   fd_set fdset;
   int fd, retval;
   int async = 0;
-  VALUE opts, defaults;
+  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);
 
   REQUIRE_OPEN_DB(wrapper);
@@ -290,8 +318,9 @@ 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
@@ -299,7 +328,24 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   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);
+    return rb_raise_mysql2_error(wrapper);
+  }
+
+  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
+    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;
   }
 
   if (!async) {
@@ -307,10 +353,32 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
     // http://github.com/datamapper/do
     fd = wrapper->client->net.fd;
     for(;;) {
+      int fd_set_fd = fd;
+
+#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
+
       FD_ZERO(&fdset);
-      FD_SET(fd, &fdset);
+      FD_SET(fd_set_fd, &fdset);
 
-      retval = rb_thread_select(fd + 1, &fdset, NULL, NULL, NULL);
+      retval = rb_thread_select(fd_set_fd + 1, &fdset, NULL, NULL, tvp);
+
+#ifdef _WIN32
+      // cleanup the CRT fd
+      _close(fd_set_fd);
+      // cleanup the duplicated SOCKET
+      closesocket(s);
+#endif
+
+      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);
@@ -321,7 +389,7 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
       }
     }
 
-    VALUE result = rb_mysql_client_async_result(self);
+    result = rb_mysql_client_async_result(self);
 
     return result;
   } else {
@@ -330,45 +398,57 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
 }
 
 static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
-  VALUE newStr;
+  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 = xmalloc(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
+    xfree(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;
+    xfree(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 +465,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();
@@ -419,17 +503,46 @@ 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);
+
+  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);
@@ -465,13 +578,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 +625,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,6 +633,23 @@ 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);
@@ -530,6 +663,11 @@ void init_mysql2_client() {
   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);