mysql2 0.1.4 → 0.1.5

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.1.5 (May 12th, 2010)
+* quite a few patches from Eric Wong related to thread-safety, non-blocking I/O and general cleanup
+** wrap mysql_real_connect with rb_thread_blocking_region
+** release GVL for possibly blocking mysql_* library calls
+** [cleanup] quiet down warnings
+** [cleanup] make all C symbols static
+** add Mysql2::Client#close method
+** correctly free the wrapped result in case of EOF
+** Fix memory leak from the result wrapper struct itself
+** make Mysql2::Client destructor safely non-blocking
+* bug fixes for ActiveRecord adapter
+** added casting for default values since they all come back from Mysql as strings (!?!)
+** missing constant was added
+** fixed a typo in the show_variable method
+* switched over sscanf for date/time parsing in C
+* made some specs a little finer-grained
+* initial Sequel adapter added
+* updated query benchmarks to reflect the difference between casting in C and in Ruby
+
 ## 0.1.4 (April 23rd, 2010)
 * optimization: implemented a local cache for rows that are lazily created in ruby during iteration. The MySQL C result is freed as soon as all the results have been cached
 * optimization: implemented a local cache for field names so every row reuses the same objects as field names/keys

data/README.rdoc

@@ -130,11 +130,11 @@ Me: Yep, but it's API is considerably more complex *and* is 2-3x slower.
 Performing a basic "SELECT * FROM" query on a table with 30k rows and fields of nearly every Ruby-representable data type,
 then iterating over every row using an #each like method yielding a block:
 
-  # And remember, the Mysql gem only gives back nil and strings for values.
+# These results are from the query_with_mysql_casting.rb script in the benchmarks folder
    user       system     total       real
   Mysql2
-   0.610000   0.160000   0.770000 (  0.986967)
+   0.890000   0.190000   1.080000 (  2.028887)
   Mysql
-   0.350000   0.220000   0.570000 (  1.457889)
+   7.330000   0.350000   7.680000 (  8.013160)
   do_mysql
-   1.710000   0.180000   1.890000 (  2.124831)
+   1.740000   0.220000   1.960000 (  2.909290)

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.5

data/benchmark/active_record.rb

@@ -15,24 +15,36 @@ mysql_opts = {
   :database => 'test'
 }
 
-class TestModel < ActiveRecord::Base
+class Mysql2Model < ActiveRecord::Base
+  set_table_name :mysql2_test
+end
+
+class MysqlModel < ActiveRecord::Base
   set_table_name :mysql2_test
 end
 
 Benchmark.bmbm do |x|
   x.report do
-    TestModel.establish_connection(mysql2_opts)
+    Mysql2Model.establish_connection(mysql2_opts)
     puts "Mysql2"
     number_of.times do
-      TestModel.all(:limit => 1000)
+      Mysql2Model.all(:limit => 1000).each{ |r|
+        r.attributes.keys.each{ |k|
+          r.send(k.to_sym)
+        }
+      }
     end
   end
 
   x.report do
-    TestModel.establish_connection(mysql_opts)
+    MysqlModel.establish_connection(mysql_opts)
     puts "Mysql"
     number_of.times do
-      TestModel.all(:limit => 1000)
+      MysqlModel.all(:limit => 1000).each{ |r|
+        r.attributes.keys.each{ |k|
+          r.send(k.to_sym)
+        }
+      }
     end
   end
 end

data/benchmark/query_with_mysql_casting.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+require 'rubygems'
+require 'benchmark'
+require 'mysql'
+require 'mysql2_ext'
+require 'do_mysql'
+
+number_of = 100
+database = 'test'
+sql = "SELECT * FROM mysql2_test LIMIT 100"
+
+class Mysql
+  include Enumerable
+end
+
+def mysql_cast(type, value)
+  case type
+    when Mysql::Field::TYPE_NULL
+      nil
+    when Mysql::Field::TYPE_TINY, Mysql::Field::TYPE_SHORT, Mysql::Field::TYPE_LONG,
+         Mysql::Field::TYPE_INT24, Mysql::Field::TYPE_LONGLONG, Mysql::Field::TYPE_YEAR
+      value.to_i
+    when Mysql::Field::TYPE_DECIMAL, Mysql::Field::TYPE_NEWDECIMAL
+      BigDecimal.new(value)
+    when Mysql::Field::TYPE_DOUBLE, Mysql::Field::TYPE_FLOAT
+      value.to_f
+    when Mysql::Field::TYPE_DATE
+      Date.parse(value)
+    when Mysql::Field::TYPE_TIME, Mysql::Field::TYPE_DATETIME, Mysql::Field::TYPE_TIMESTAMP
+      Time.parse(value)
+    when Mysql::Field::TYPE_BLOB, Mysql::Field::TYPE_BIT, Mysql::Field::TYPE_STRING,
+         Mysql::Field::TYPE_VAR_STRING, Mysql::Field::TYPE_CHAR, Mysql::Field::TYPE_SET
+         Mysql::Field::TYPE_ENUM
+      value
+    else
+      value
+  end
+end
+
+Benchmark.bmbm do |x|
+  mysql2 = Mysql2::Client.new(:host => "localhost", :username => "root")
+  mysql2.query "USE #{database}"
+  x.report do
+    puts "Mysql2"
+    number_of.times do
+      mysql2_result = mysql2.query sql
+      mysql2_result.each(:symbolize_keys => true) do |res|
+        # puts res.inspect
+      end
+    end
+  end
+
+  mysql = Mysql.new("localhost", "root")
+  mysql.query "USE #{database}"
+  x.report do
+    puts "Mysql"
+    number_of.times do
+      mysql_result = mysql.query sql
+      fields = mysql_result.fetch_fields
+      mysql_result.each do |row|
+        row_hash = {}
+        row.each_with_index do |f, j|
+          row_hash[fields[j].name.to_sym] = mysql_cast(fields[j].type, row[j])
+        end
+        # puts row_hash.inspect
+      end
+    end
+  end
+
+  do_mysql = DataObjects::Connection.new("mysql://localhost/#{database}")
+  command = DataObjects::Mysql::Command.new do_mysql, sql
+  x.report do
+    puts "do_mysql"
+    number_of.times do
+      do_result = command.execute_reader
+      do_result.each do |res|
+        # puts res.inspect
+      end
+    end
+  end
+end

data/benchmark/sequel.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'benchmark'
+require 'sequel'
+require 'sequel/adapters/do'
+
+number_of = 10
+mysql2_opts = "mysql2://localhost/test"
+mysql_opts = "mysql://localhost/test"
+do_mysql_opts = "do:mysql://localhost/test"
+
+class Mysql2Model < Sequel::Model(Sequel.connect(mysql2_opts)[:mysql2_test]); end
+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"
+    number_of.times do
+      Mysql2Model.limit(1000).all
+    end
+  end
+
+  x.report do
+    puts "do:mysql"
+    number_of.times do
+      DOMysqlModel.limit(1000).all
+    end
+  end
+
+  x.report do
+    puts "Mysql"
+    number_of.times do
+      MysqlModel.limit(1000).all
+    end
+  end
+end

data/ext/extconf.rb

@@ -1,6 +1,9 @@
 # encoding: UTF-8
 require 'mkmf'
 
+# 1.9-only
+have_func('rb_thread_blocking_region')
+
 # borrowed from mysqlplus
 # http://github.com/oldmoe/mysqlplus/blob/master/ext/extconf.rb
 dirs = ENV['PATH'].split(':') + %w[

data/ext/mysql2_ext.c

@@ -1,54 +1,105 @@
 #include "mysql2_ext.h"
 
+/*
+ * non-blocking mysql_*() functions that we won't be wrapping since
+ * they do not appear to hit the network nor issue any interruptible
+ * or blocking system calls.
+ *
+ * - mysql_affected_rows()
+ * - mysql_error()
+ * - mysql_fetch_fields()
+ * - mysql_fetch_lengths() - calls cli_fetch_lengths or emb_fetch_lengths
+ * - mysql_field_count()
+ * - mysql_get_client_info()
+ * - mysql_get_client_version()
+ * - mysql_get_server_info()
+ * - mysql_get_server_version()
+ * - mysql_insert_id()
+ * - mysql_num_fields()
+ * - mysql_num_rows()
+ * - mysql_options()
+ * - mysql_real_escape_string()
+ * - mysql_ssl_set()
+ */
+
+static VALUE nogvl_init(void *ptr) {
+  struct nogvl_connect_args *args = ptr;
+
+  /* may initialize embedded server and read /etc/services off disk */
+  args->mysql = mysql_init(NULL);
+
+  return args->mysql == NULL ? Qfalse : Qtrue;
+}
+
+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);
+
+  return client ? Qtrue : Qfalse;
+}
+
 /* Mysql2::Client */
 static VALUE rb_mysql_client_new(int argc, VALUE * argv, VALUE klass) {
-  MYSQL * client;
+  mysql2_client_wrapper * client;
+  struct nogvl_connect_args args = {
+    .host = "localhost",
+    .user = NULL,
+    .passwd = NULL,
+    .db = NULL,
+    .port = 3306,
+    .unix_socket = NULL,
+    .client_flag = 0
+  };
   VALUE obj, opts;
   VALUE rb_host, rb_socket, rb_port, rb_database,
         rb_username, rb_password, rb_reconnect,
         rb_connect_timeout;
   VALUE rb_ssl_client_key, rb_ssl_client_cert, rb_ssl_ca_cert,
         rb_ssl_ca_path, rb_ssl_cipher;
-  char *host = "localhost", *socket = NULL, *username = NULL,
-       *password = NULL, *database = NULL;
   char *ssl_client_key = NULL, *ssl_client_cert = NULL, *ssl_ca_cert = NULL,
        *ssl_ca_path = NULL, *ssl_cipher = NULL;
-  unsigned int port = 3306, connect_timeout = 0;
+  unsigned int connect_timeout = 0;
   my_bool reconnect = 1;
 
-  obj = Data_Make_Struct(klass, MYSQL, NULL, rb_mysql_client_free, client);
+  obj = Data_Make_Struct(klass, mysql2_client_wrapper, NULL, rb_mysql_client_free, client);
 
   if (rb_scan_args(argc, argv, "01", &opts) == 1) {
     Check_Type(opts, T_HASH);
 
     if ((rb_host = rb_hash_aref(opts, sym_host)) != Qnil) {
       Check_Type(rb_host, T_STRING);
-      host = RSTRING_PTR(rb_host);
+      args.host = RSTRING_PTR(rb_host);
     }
 
     if ((rb_socket = rb_hash_aref(opts, sym_socket)) != Qnil) {
       Check_Type(rb_socket, T_STRING);
-      socket = RSTRING_PTR(rb_socket);
+      args.unix_socket = RSTRING_PTR(rb_socket);
     }
 
     if ((rb_port = rb_hash_aref(opts, sym_port)) != Qnil) {
       Check_Type(rb_port, T_FIXNUM);
-      port = FIX2INT(rb_port);
+      args.port = FIX2INT(rb_port);
     }
 
     if ((rb_username = rb_hash_aref(opts, sym_username)) != Qnil) {
       Check_Type(rb_username, T_STRING);
-      username = RSTRING_PTR(rb_username);
+      args.user = RSTRING_PTR(rb_username);
     }
 
     if ((rb_password = rb_hash_aref(opts, sym_password)) != Qnil) {
       Check_Type(rb_password, T_STRING);
-      password = RSTRING_PTR(rb_password);
+      args.passwd = RSTRING_PTR(rb_password);
     }
 
     if ((rb_database = rb_hash_aref(opts, sym_database)) != Qnil) {
       Check_Type(rb_database, T_STRING);
-      database = RSTRING_PTR(rb_database);
+      args.db = RSTRING_PTR(rb_database);
     }
 
     if ((rb_reconnect = rb_hash_aref(opts, sym_reconnect)) != Qnil) {
@@ -87,82 +138,145 @@ static VALUE rb_mysql_client_new(int argc, VALUE * argv, VALUE klass) {
     }
   }
 
-  if (!mysql_init(client)) {
+  if (rb_thread_blocking_region(nogvl_init, &args, RUBY_UBF_IO, 0) == Qfalse) {
     // TODO: warning - not enough memory?
-    rb_raise(cMysql2Error, "%s", mysql_error(client));
+    rb_raise(cMysql2Error, "%s", mysql_error(args.mysql));
     return Qnil;
   }
 
   // set default reconnect behavior
-  if (mysql_options(client, MYSQL_OPT_RECONNECT, &reconnect) != 0) {
+  if (mysql_options(args.mysql, MYSQL_OPT_RECONNECT, &reconnect) != 0) {
     // TODO: warning - unable to set reconnect behavior
-    rb_warn("%s\n", mysql_error(client));
+    rb_warn("%s\n", mysql_error(args.mysql));
   }
 
   // set default connection timeout behavior
-  if (connect_timeout != 0 && mysql_options(client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout) != 0) {
+  if (connect_timeout != 0 && mysql_options(args.mysql, MYSQL_OPT_CONNECT_TIMEOUT, (const char *)&connect_timeout) != 0) {
     // TODO: warning - unable to set connection timeout
-    rb_warn("%s\n", mysql_error(client));
+    rb_warn("%s\n", mysql_error(args.mysql));
   }
 
   // force the encoding to utf8
-  if (mysql_options(client, MYSQL_SET_CHARSET_NAME, "utf8") != 0) {
+  if (mysql_options(args.mysql, MYSQL_SET_CHARSET_NAME, "utf8") != 0) {
     // TODO: warning - unable to set charset
-    rb_warn("%s\n", mysql_error(client));
+    rb_warn("%s\n", mysql_error(args.mysql));
   }
 
   if (ssl_ca_cert != NULL || ssl_client_key != NULL) {
-    mysql_ssl_set(client, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
+    mysql_ssl_set(args.mysql, ssl_client_key, ssl_client_cert, ssl_ca_cert, ssl_ca_path, ssl_cipher);
   }
 
-  if (mysql_real_connect(client, host, username, password, database, port, socket, 0) == NULL) {
+  if (rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0) == Qfalse) {
     // unable to connect
-    rb_raise(cMysql2Error, "%s", mysql_error(client));
+    rb_raise(cMysql2Error, "%s", mysql_error(args.mysql));
     return Qnil;
   }
 
+  client->client = args.mysql;
+
   rb_obj_call_init(obj, argc, argv);
   return obj;
 }
 
-static VALUE rb_mysql_client_init(int argc, VALUE * argv, VALUE self) {
+static VALUE rb_mysql_client_init(RB_MYSQL_UNUSED int argc, RB_MYSQL_UNUSED VALUE * argv, VALUE self) {
   return self;
 }
 
-void rb_mysql_client_free(void * client) {
-  MYSQL * c = client;
-  if (c) {
-    mysql_close(client);
+static void rb_mysql_client_free(void * ptr) {
+  mysql2_client_wrapper * client = ptr;
+
+  if (client->client) {
+    /*
+     * 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
+     */
+    int fd = client->client->net.fd;
+    int flags;
+
+    if (fd >= 0) {
+      /*
+       * if the socket is dead we have no chance of blocking,
+       * so ignore any potential fcntl errors since they don't matter
+       */
+      flags = fcntl(fd, F_GETFL);
+      if (flags > 0 && !(flags & O_NONBLOCK))
+        fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+    }
+
+    mysql_close(client->client);
   }
+  xfree(ptr);
+}
+
+static VALUE nogvl_close(void * ptr) {
+  mysql_close((MYSQL *)ptr);
+  return Qnil;
+}
+
+/*
+ * Immediately disconnect from the server, normally the garbage collector
+ * will disconnect automatically when a connection is no longer needed.
+ * Explicitly closing this will free up server resources sooner than waiting
+ * for the garbage collector.
+ */
+static VALUE rb_mysql_client_close(VALUE self) {
+  mysql2_client_wrapper *client;
+
+	Data_Get_Struct(self, mysql2_client_wrapper, client);
+
+  if (client->client) {
+    rb_thread_blocking_region(nogvl_close, client->client, RUBY_UBF_IO, 0);
+    client->client = NULL;
+  } else {
+    rb_raise(cMysql2Error, "already closed MySQL connection");
+  }
+  return Qnil;
+}
+
+/*
+ * mysql_send_query is unlikely to block since most queries are small
+ * enough to fit in a socket buffer, but sometimes large UPDATE and
+ * INSERTs will cause the process to block
+ */
+static VALUE nogvl_send_query(void *ptr)
+{
+  struct nogvl_send_query_args *args = ptr;
+  int rv;
+  const char *sql = RSTRING_PTR(args->sql);
+  long sql_len = RSTRING_LEN(args->sql);
+
+  rv = mysql_send_query(args->mysql, sql, sql_len);
+
+  return rv == 0 ? Qtrue : Qfalse;
 }
 
 static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
-  MYSQL * client;
-  MYSQL_RES * result;
+  struct nogvl_send_query_args args;
   fd_set fdset;
   int fd, retval;
   int async = 0;
-  VALUE sql, opts;
+  VALUE opts;
   VALUE rb_async;
 
-  if (rb_scan_args(argc, argv, "11", &sql, &opts) == 2) {
+  if (rb_scan_args(argc, argv, "11", &args.sql, &opts) == 2) {
     if ((rb_async = rb_hash_aref(opts, sym_async)) != Qnil) {
       async = rb_async == Qtrue ? 1 : 0;
     }
   }
 
-  Check_Type(sql, T_STRING);
+  Check_Type(args.sql, T_STRING);
 
-  GetMysql2Client(self, client);
-  if (mysql_send_query(client, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0) {
-    rb_raise(cMysql2Error, "%s", mysql_error(client));
+  GetMysql2Client(self, args.mysql);
+  if (rb_thread_blocking_region(nogvl_send_query, &args, RUBY_UBF_IO, 0) == Qfalse) {
+    rb_raise(cMysql2Error, "%s", mysql_error(args.mysql));
     return Qnil;
   }
 
   if (!async) {
     // the below code is largely from do_mysql
     // http://github.com/datamapper/do
-    fd = client->net.fd;
+    fd = args.mysql->net.fd;
     for(;;) {
       FD_ZERO(&fdset);
       FD_SET(fd, &fdset);
@@ -208,7 +322,7 @@ static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
   }
 }
 
-static VALUE rb_mysql_client_info(VALUE self) {
+static VALUE rb_mysql_client_info(RB_MYSQL_UNUSED VALUE self) {
   VALUE version = rb_hash_new();
   rb_hash_aset(version, sym_id, LONG2FIX(mysql_get_client_version()));
   rb_hash_aset(version, sym_version, rb_str_new2(mysql_get_client_info()));
@@ -231,17 +345,37 @@ static VALUE rb_mysql_client_socket(VALUE self) {
   return INT2NUM(client->net.fd);
 }
 
+/*
+ * even though we did rb_thread_select before calling this, a large
+ * response can overflow the socket buffers and cause us to eventually
+ * block while calling mysql_read_query_result
+ */
+static VALUE nogvl_read_query_result(void *ptr)
+{
+  MYSQL * client = ptr;
+  my_bool res = mysql_read_query_result(client);
+
+  return res == 0 ? Qtrue : Qfalse;
+}
+
+/* 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);
+}
+
 static VALUE rb_mysql_client_async_result(VALUE self) {
   MYSQL * client;
   MYSQL_RES * result;
   GetMysql2Client(self, client);
 
-  if (mysql_read_query_result(client) != 0) {
+  if (rb_thread_blocking_region(nogvl_read_query_result, client, RUBY_UBF_IO, 0) == Qfalse) {
     rb_raise(cMysql2Error, "%s", mysql_error(client));
     return Qnil;
   }
 
-  result = mysql_store_result(client);
+  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, client, RUBY_UBF_IO, 0);
   if (result == NULL) {
     if (mysql_field_count(client) != 0) {
       rb_raise(cMysql2Error, "%s", mysql_error(client));
@@ -280,15 +414,23 @@ static VALUE rb_mysql_result_to_obj(MYSQL_RES * r) {
   return obj;
 }
 
-void rb_mysql_result_free(void * wrapper) {
-  mysql2_result_wrapper * w = wrapper;
-  if (w && w->resultFreed != 1) {
-    mysql_free_result(w->result);
-    w->resultFreed = 1;
+/* this may be called manually or during GC */
+static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
+  if (wrapper && wrapper->resultFreed != 1) {
+    mysql_free_result(wrapper->result);
+    wrapper->resultFreed = 1;
   }
 }
 
-void rb_mysql_result_mark(void * wrapper) {
+/* this is called during GC */
+static void rb_mysql_result_free(void * wrapper) {
+  mysql2_result_wrapper * w = wrapper;
+  /* FIXME: this may call flush_use_result, which can hit the socket */
+  rb_mysql_result_free_result(w);
+  xfree(wrapper);
+}
+
+static void rb_mysql_result_mark(void * wrapper) {
     mysql2_result_wrapper * w = wrapper;
     if (w) {
         rb_gc_mark(w->fields);
@@ -296,14 +438,26 @@ void rb_mysql_result_mark(void * wrapper) {
     }
 }
 
+/*
+ * for small results, this won't hit the network, but there's no
+ * reliable way for us to tell this so we'll always release the GVL
+ * to be safe
+ */
+static VALUE nogvl_fetch_row(void *ptr)
+{
+  MYSQL_RES *result = ptr;
+
+  return (VALUE)mysql_fetch_row(result);
+}
+
 static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
   VALUE rowHash, opts, block;
   mysql2_result_wrapper * wrapper;
   MYSQL_ROW row;
   MYSQL_FIELD * fields = NULL;
-  struct tm parsedTime;
   unsigned int i = 0, symbolizeKeys = 0;
   unsigned long * fieldLengths;
+  void * ptr;
 
   GetMysql2Result(self, wrapper);
 
@@ -314,7 +468,8 @@ static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
     }
   }
 
-  row = mysql_fetch_row(wrapper->result);
+  ptr = wrapper->result;
+  row = (MYSQL_ROW)rb_thread_blocking_region(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0);
   if (row == NULL) {
     return Qnil;
   }
@@ -353,8 +508,10 @@ static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
         case MYSQL_TYPE_NULL:       // NULL-type field
           val = Qnil;
           break;
-        case MYSQL_TYPE_TINY:       // TINYINT field
         case MYSQL_TYPE_BIT:        // BIT field (MySQL 5.0.3 and up)
+          val = rb_str_new(row[i], fieldLengths[i]);
+          break;
+        case MYSQL_TYPE_TINY:       // TINYINT field
         case MYSQL_TYPE_SHORT:      // SMALLINT field
         case MYSQL_TYPE_LONG:       // INTEGER field
         case MYSQL_TYPE_INT24:      // MEDIUMINT field
@@ -370,32 +527,42 @@ static VALUE rb_mysql_result_fetch_row(int argc, VALUE * argv, VALUE self) {
         case MYSQL_TYPE_DOUBLE:     // DOUBLE or REAL field
           val = rb_float_new(strtod(row[i], NULL));
           break;
-        case MYSQL_TYPE_TIME:       // TIME field
-          if (memcmp("00:00:00", row[i], 8) == 0) {
-            val = Qnil;
-          } else {
-            strptime(row[i], "%T", &parsedTime);
-            val = rb_funcall(rb_cTime, intern_local, 6, INT2NUM(1900+parsedTime.tm_year), INT2NUM(parsedTime.tm_mon+1), INT2NUM(parsedTime.tm_mday), INT2NUM(parsedTime.tm_hour), INT2NUM(parsedTime.tm_min), INT2NUM(parsedTime.tm_sec));
-          }
+        case MYSQL_TYPE_TIME: {     // TIME field
+          int hour, min, sec, tokens;
+          tokens = sscanf(row[i], "%2d:%2d:%2d", &hour, &min, &sec);
+          val = rb_funcall(rb_cTime, intern_local, 6, INT2NUM(0), INT2NUM(1), INT2NUM(1), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
           break;
+        }
         case MYSQL_TYPE_TIMESTAMP:  // TIMESTAMP field
-        case MYSQL_TYPE_DATETIME:   // DATETIME field
-          if (memcmp("0000-00-00 00:00:00", row[i], 19) == 0) {
+        case MYSQL_TYPE_DATETIME: { // DATETIME field
+          int year, month, day, hour, min, sec, tokens;
+          tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec);
+          if (year+month+day+hour+min+sec == 0) {
             val = Qnil;
           } else {
-            strptime(row[i], "%F %T", &parsedTime);
-            val = rb_funcall(rb_cTime, intern_local, 6, INT2NUM(1900+parsedTime.tm_year), INT2NUM(parsedTime.tm_mon+1), INT2NUM(parsedTime.tm_mday), INT2NUM(parsedTime.tm_hour), INT2NUM(parsedTime.tm_min), INT2NUM(parsedTime.tm_sec));
+            if (month < 1 || day < 1) {
+              rb_raise(cMysql2Error, "Invalid date: %s", row[i]);
+            } else {
+              val = rb_funcall(rb_cTime, intern_local, 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+            }
           }
           break;
+        }
         case MYSQL_TYPE_DATE:       // DATE field
-        case MYSQL_TYPE_NEWDATE:    // Newer const used > 5.0
-          if (memcmp("0000-00-00", row[i], 10) == 0) {
+        case MYSQL_TYPE_NEWDATE: {  // Newer const used > 5.0
+          int year, month, day, tokens;
+          tokens = sscanf(row[i], "%4d-%2d-%2d", &year, &month, &day);
+          if (year+month+day == 0) {
             val = Qnil;
           } else {
-            strptime(row[i], "%F", &parsedTime);
-            val = rb_funcall(rb_cTime, intern_local, 3, INT2NUM(1900+parsedTime.tm_year), INT2NUM(parsedTime.tm_mon+1), INT2NUM(parsedTime.tm_mday));
+            if (month < 1 || day < 1) {
+              rb_raise(cMysql2Error, "Invalid date: %s", row[i]);
+            } else {
+              val = rb_funcall(cDate, intern_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+            }
           }
           break;
+        }
         case MYSQL_TYPE_TINY_BLOB:
         case MYSQL_TYPE_MEDIUM_BLOB:
         case MYSQL_TYPE_LONG_BLOB:
@@ -464,7 +631,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
       if (row == Qnil) {
         // we don't need the mysql C dataset around anymore, peace it
-        rb_mysql_result_free(wrapper->result);
+        rb_mysql_result_free_result(wrapper);
         return Qnil;
       }
 
@@ -474,7 +641,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     }
     if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
       // we don't need the mysql C dataset around anymore, peace it
-      rb_mysql_result_free(wrapper);
+      rb_mysql_result_free_result(wrapper);
     }
   }
 
@@ -495,6 +662,7 @@ void Init_mysql2_ext() {
   VALUE cMysql2Client = rb_define_class_under(mMysql2, "Client", rb_cObject);
   rb_define_singleton_method(cMysql2Client, "new", rb_mysql_client_new, -1);
   rb_define_method(cMysql2Client, "initialize", rb_mysql_client_init, -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, "info", rb_mysql_client_info, 0);
@@ -537,4 +705,4 @@ void Init_mysql2_ext() {
   utf8Encoding = rb_enc_find_index("UTF-8");
   binaryEncoding = rb_enc_find_index("binary");
 #endif
-}
+}