mysql2 0.2.8 → 0.2.9

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.2.9 (June 15th, 2011)
+* fix a long standing bug where a signal would interrupt rb_thread_select and put the connection in a permanently broken state
+* turn on casting in the ActiveRecord again, users can disable it if they need to for performance reasons
+
 ## 0.2.8 (June 14th, 2011)
 * disable async support, and access to the underlying file descriptor under Windows. It's never worked reliably and ruby-core has a lot of work to do in order to make it possible.
 * added support for turning eager-casting off. This is especially useful in ORMs that will lazily cast values upon access.

data/ext/mysql2/client.c

@@ -1,6 +1,9 @@
 #include <mysql2_ext.h>
 #include <client.h>
 #include <errno.h>
+#ifndef _WIN32
+#include <sys/socket.h>
+#endif
 
 VALUE cMysql2Client;
 extern VALUE mMysql2, cMysql2Error;
@@ -9,7 +12,7 @@ static VALUE sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_arr
 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"); \
   }
 
@@ -125,7 +128,7 @@ static VALUE nogvl_close(void *ptr) {
   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
@@ -162,6 +165,7 @@ 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*)xmalloc(sizeof(MYSQL));
   return obj;
@@ -271,6 +275,10 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
 #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
@@ -301,19 +309,89 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
   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;
+}
+#endif
+
+static VALUE do_query(void *args) {
+  struct async_query_args *async_args;
+  struct timeval tv;
+  struct timeval* tvp;
+  long int sec;
+  fd_set fdset;
+  int retval;
+  int fd_set_fd;
+  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;
+  }
+
+  fd_set_fd = async_args->fd;
+  for(;;) {
+    // the below code is largely from do_mysql
+    // http://github.com/datamapper/do
+    FD_ZERO(&fdset);
+    FD_SET(fd_set_fd, &fdset);
+
+    retval = rb_thread_select(fd_set_fd + 1, &fdset, NULL, NULL, 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;
+}
+
 static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
+  struct async_query_args async_args;
   struct nogvl_send_query_args args;
-  fd_set fdset;
-  int fd, retval;
   int async = 0;
-  VALUE opts, defaults, read_timeout;
+  VALUE opts, defaults;
 #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);
@@ -353,51 +431,13 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   }
 
 #ifndef _WIN32
-  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) {
-    // the below code is largely from do_mysql
-    // http://github.com/datamapper/do
-    fd = wrapper->client->net.fd;
-    for(;;) {
-      int fd_set_fd = fd;
-
-      FD_ZERO(&fdset);
-      FD_SET(fd_set_fd, &fdset);
-
-      retval = rb_thread_select(fd_set_fd + 1, &fdset, NULL, NULL, 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;
-      }
-    }
+    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 result;
+    return rb_mysql_client_async_result(self);
   } else {
     return Qnil;
   }
@@ -568,6 +608,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 */

data/ext/mysql2/client.h

@@ -33,8 +33,9 @@ void init_mysql2_client();
 
 typedef struct {
   VALUE encoding;
-  char active;
-  char closed;
+  int active;
+  int reconnect_enabled;
+  int closed;
   MYSQL *client;
 } mysql_client_wrapper;
 

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -562,7 +562,7 @@ module ActiveRecord
         end
 
         def configure_connection
-          @connection.query_options.merge!(:as => :array, :cast => false)
+          @connection.query_options.merge!(:as => :array)
 
           # By default, MySQL 'where id is null' selects the last inserted id.
           # Turn this off. http://dev.rubyonrails.org/ticket/6778

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.2.8"
+  VERSION = "0.2.9"
 end

data/spec/mysql2/client_spec.rb

@@ -116,13 +116,6 @@ describe Mysql2::Client do
       @client.query("SELECT 1", :symbolize_keys => true).first.keys[0].class.should eql(Symbol)
     end
 
-    it "should not allow another query to be sent without fetching a result first" do
-      @client.query("SELECT 1", :async => true)
-      lambda {
-        @client.query("SELECT 1")
-      }.should raise_error(Mysql2::Error)
-    end
-
     it "should require an open connection" do
       @client.close
       lambda {
@@ -130,16 +123,23 @@ describe Mysql2::Client do
       }.should raise_error(Mysql2::Error)
     end
 
-    it "should timeout if we wait longer than :read_timeout" do
-      client = Mysql2::Client.new(:read_timeout => 1)
-      lambda {
-        client.query("SELECT sleep(2)")
-      }.should raise_error(Mysql2::Error)
-    end
-
-    # XXX this test is not deterministic (because Unix signal handling is not)
-    # and may fail on a loaded system
     if RUBY_PLATFORM !~ /mingw|mswin/
+      it "should not allow another query to be sent without fetching a result first" do
+        @client.query("SELECT 1", :async => true)
+        lambda {
+          @client.query("SELECT 1")
+        }.should raise_error(Mysql2::Error)
+      end
+
+      it "should timeout if we wait longer than :read_timeout" do
+        client = Mysql2::Client.new(:read_timeout => 1)
+        lambda {
+          client.query("SELECT sleep(2)")
+        }.should raise_error(Mysql2::Error)
+      end
+
+      # XXX this test is not deterministic (because Unix signal handling is not)
+      # and may fail on a loaded system
       it "should run signal handlers while waiting for a response" do
         mark = {}
         trap(:USR1) { mark[:USR1] = Time.now }
@@ -164,6 +164,92 @@ describe Mysql2::Client do
           trap(:USR1, 'DEFAULT')
         end
       end
+
+      it "#socket should return a Fixnum (file descriptor from C)" do
+        @client.socket.class.should eql(Fixnum)
+        @client.socket.should_not eql(0)
+      end
+
+      it "#socket should require an open connection" do
+        @client.close
+        lambda {
+          @client.socket
+        }.should raise_error(Mysql2::Error)
+      end
+
+      it "should close the connection when an exception is raised" do
+        begin
+          Timeout.timeout(1) do
+            @client.query("SELECT sleep(2)")
+          end
+        rescue Timeout::Error
+        end
+        
+        lambda {
+          @client.query("SELECT 1")
+        }.should raise_error(Mysql2::Error, 'closed MySQL connection')
+      end
+
+      it "should handle Timeouts without leaving the connection hanging if reconnect is true" do
+        client = Mysql2::Client.new(:reconnect => true)
+        begin
+          Timeout.timeout(1) do
+            client.query("SELECT sleep(2)")
+          end
+        rescue Timeout::Error
+        end
+
+        lambda {
+          client.query("SELECT 1")
+        }.should_not raise_error(Mysql2::Error)
+      end
+
+      it "threaded queries should be supported" do
+        threads, results = [], {}
+        connect = lambda{ Mysql2::Client.new(:host => "localhost", :username => "root") }
+        Timeout.timeout(0.7) do
+          5.times {
+            threads << Thread.new do
+              results[Thread.current.object_id] = connect.call.query("SELECT sleep(0.5) as result")
+            end
+          }
+        end
+        threads.each{|t| t.join }
+        results.keys.sort.should eql(threads.map{|t| t.object_id }.sort)
+      end
+
+      it "evented async queries should be supported" do
+        # should immediately return nil
+        @client.query("SELECT sleep(0.1)", :async => true).should eql(nil)
+
+        io_wrapper = IO.for_fd(@client.socket)
+        loops = 0
+        loop do
+          if IO.select([io_wrapper], nil, nil, 0.05)
+            break
+          else
+            loops += 1
+          end
+        end
+
+        # make sure we waited some period of time
+        (loops >= 1).should be_true
+
+        result = @client.async_result
+        result.class.should eql(Mysql2::Result)
+      end
+    end
+  end
+
+  it "should respond to #socket" do
+    @client.should respond_to(:socket)
+  end
+
+  if RUBY_PLATFORM =~ /mingw|mswin/
+    it "#socket should raise as it's not supported" do
+      lambda {
+        @client.socket
+      }.should raise_error(Mysql2::Error)
     end
   end
 
@@ -311,22 +397,6 @@ describe Mysql2::Client do
     end
   end
 
-  it "should respond to #socket" do
-    @client.should respond_to(:socket)
-  end
-
-  it "#socket should return a Fixnum (file descriptor from C)" do
-    @client.socket.class.should eql(Fixnum)
-    @client.socket.should_not eql(0)
-  end
-
-  it "#socket should require an open connection" do
-    @client.close
-    lambda {
-      @client.socket
-    }.should raise_error(Mysql2::Error)
-  end
-
   it "should raise a Mysql2::Error exception upon connection failure" do
     lambda {
       bad_client = Mysql2::Client.new :host => "localhost", :username => 'asdfasdf8d2h', :password => 'asdfasdfw42'
@@ -337,41 +407,6 @@ describe Mysql2::Client do
     }.should_not raise_error(Mysql2::Error)
   end
 
-  it "threaded queries should be supported" do
-    threads, results = [], {}
-    connect = lambda{ Mysql2::Client.new(:host => "localhost", :username => "root") }
-    Timeout.timeout(0.7) do
-      5.times {
-        threads << Thread.new do
-          results[Thread.current.object_id] = connect.call.query("SELECT sleep(0.5) as result")
-        end
-      }
-    end
-    threads.each{|t| t.join }
-    results.keys.sort.should eql(threads.map{|t| t.object_id }.sort)
-  end
-
-  it "evented async queries should be supported" do
-    # should immediately return nil
-    @client.query("SELECT sleep(0.1)", :async => true).should eql(nil)
-
-    io_wrapper = IO.for_fd(@client.socket)
-    loops = 0
-    loop do
-      if IO.select([io_wrapper], nil, nil, 0.05)
-        break
-      else
-        loops += 1
-      end
-    end
-
-    # make sure we waited some period of time
-    (loops >= 1).should be_true
-
-    result = @client.async_result
-    result.class.should eql(Mysql2::Result)
-  end
-
   context 'write operations api' do
     before(:each) do
       @client.query "USE test"

data/spec/mysql2/result_spec.rb

@@ -28,6 +28,12 @@ describe Mysql2::Result do
     }.should_not raise_error(Mysql2::Error)
   end
 
+  context "metadata queries" do
+    it "should show tables" do
+      @result = @client.query "SHOW TABLES"
+    end
+  end
+
   context "#each" do
     it "should yield rows as hash's" do
       @result.each do |row|

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mysql2
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 2
-  - 8
-  version: 0.2.8
+  - 9
+  version: 0.2.9
 platform: ruby
 authors: 
 - Brian Lopez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-14 00:00:00 -07:00
+date: 2011-06-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency