mysql2 0.3.17 → 0.3.20

data/ext/mysql2/result.c

@@ -50,6 +50,10 @@ static rb_encoding *binaryEncoding;
 #define MYSQL2_MIN_TIME 62171150401ULL
 #endif
 
+#define GET_RESULT(obj) \
+  mysql2_result_wrapper *wrapper; \
+  Data_Get_Struct(self, mysql2_result_wrapper, wrapper);
+
 static VALUE cMysql2Result;
 static VALUE cBigDecimal, cDate, cDateTime;
 static VALUE opt_decimal_zero, opt_float_zero, opt_time_year, opt_time_month, opt_utc_offset;
@@ -103,9 +107,8 @@ static void *nogvl_fetch_row(void *ptr) {
 }
 
 static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int symbolize_keys) {
-  mysql2_result_wrapper * wrapper;
   VALUE rb_field;
-  GetMysql2Result(self, wrapper);
+  GET_RESULT(self);
 
   if (wrapper->fields == Qnil) {
     wrapper->numberOfFields = mysql_num_fields(wrapper->result);
@@ -193,7 +196,6 @@ static unsigned int msec_char_to_uint(char *msec_char, size_t len)
 
 static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast, MYSQL_FIELD * fields) {
   VALUE rowVal;
-  mysql2_result_wrapper * wrapper;
   MYSQL_ROW row;
   unsigned int i = 0;
   unsigned long * fieldLengths;
@@ -202,7 +204,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
   rb_encoding *default_internal_enc;
   rb_encoding *conn_enc;
 #endif
-  GetMysql2Result(self, wrapper);
+  GET_RESULT(self);
 
 #ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
@@ -232,7 +234,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
       VALUE val = Qnil;
       enum enum_field_types type = fields[i].type;
 
-      if(!cast) {
+      if (!cast) {
         if (type == MYSQL_TYPE_NULL) {
           val = Qnil;
         } else {
@@ -297,7 +299,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
             break;
           }
           msec = msec_char_to_uint(msec_char, sizeof(msec_char));
-          val = rb_funcall(rb_cTime, db_timezone, 6, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec));
+          val = rb_funcall(rb_cTime, db_timezone, 7, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec));
           if (!NIL_P(app_timezone)) {
             if (app_timezone == intern_local) {
               val = rb_funcall(val, intern_localtime, 0);
@@ -413,12 +415,11 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
 }
 
 static VALUE rb_mysql_result_fetch_fields(VALUE self) {
-  mysql2_result_wrapper * wrapper;
   unsigned int i = 0;
   short int symbolizeKeys = 0;
   VALUE defaults;
 
-  GetMysql2Result(self, wrapper);
+  GET_RESULT(self);
 
   defaults = rb_iv_get(self, "@query_options");
   Check_Type(defaults, T_HASH);
@@ -443,13 +444,12 @@ static VALUE rb_mysql_result_fetch_fields(VALUE self) {
 static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   VALUE defaults, opts, block;
   ID db_timezone, app_timezone, dbTz, appTz;
-  mysql2_result_wrapper * wrapper;
   unsigned long i;
   const char * errstr;
-  int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1, streaming = 0;
+  int symbolizeKeys, asArray, castBool, cacheRows, cast;
   MYSQL_FIELD * fields = NULL;
 
-  GetMysql2Result(self, wrapper);
+  GET_RESULT(self);
 
   defaults = rb_iv_get(self, "@query_options");
   Check_Type(defaults, T_HASH);
@@ -459,32 +459,14 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     opts = defaults;
   }
 
-  if (rb_hash_aref(opts, sym_symbolize_keys) == Qtrue) {
-    symbolizeKeys = 1;
-  }
-
-  if (rb_hash_aref(opts, sym_as) == sym_array) {
-    asArray = 1;
-  }
-
-  if (rb_hash_aref(opts, sym_cast_booleans) == Qtrue) {
-    castBool = 1;
-  }
-
-  if (rb_hash_aref(opts, sym_cache_rows) == Qfalse) {
-    cacheRows = 0;
-  }
-
-  if (rb_hash_aref(opts, sym_cast) == Qfalse) {
-    cast = 0;
-  }
-
-  if(rb_hash_aref(opts, sym_stream) == Qtrue) {
-    streaming = 1;
-  }
+  symbolizeKeys = RTEST(rb_hash_aref(opts, sym_symbolize_keys));
+  asArray       = rb_hash_aref(opts, sym_as) == sym_array;
+  castBool      = RTEST(rb_hash_aref(opts, sym_cast_booleans));
+  cacheRows     = RTEST(rb_hash_aref(opts, sym_cache_rows));
+  cast          = RTEST(rb_hash_aref(opts, sym_cast));
 
-  if(streaming && cacheRows) {
-    rb_warn("cacheRows is ignored if streaming is true");
+  if (wrapper->is_streaming && cacheRows) {
+    rb_warn(":cache_rows is ignored if :stream is true");
   }
 
   dbTz = rb_hash_aref(opts, sym_database_timezone);
@@ -508,23 +490,12 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     app_timezone = Qnil;
   }
 
-  if (wrapper->lastRowProcessed == 0) {
-    if (streaming) {
-      /* We can't get number of rows if we're streaming, */
-      /* until we've finished fetching all rows */
-      wrapper->numberOfRows = 0;
+  if (wrapper->is_streaming) {
+    /* When streaming, we will only yield rows, not return them. */
+    if (wrapper->rows == Qnil) {
       wrapper->rows = rb_ary_new();
-    } else {
-      wrapper->numberOfRows = mysql_num_rows(wrapper->result);
-      if (wrapper->numberOfRows == 0) {
-        wrapper->rows = rb_ary_new();
-        return wrapper->rows;
-      }
-      wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
     }
-  }
 
-  if (streaming) {
     if (!wrapper->streamingComplete) {
       VALUE row;
 
@@ -532,16 +503,15 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
       do {
         row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields);
-
-        if (block != Qnil && row != Qnil) {
-          rb_yield(row);
-          wrapper->lastRowProcessed++;
+        if (row != Qnil) {
+          wrapper->numberOfRows++;
+          if (block != Qnil) {
+            rb_yield(row);
+          }
         }
       } while(row != Qnil);
 
       rb_mysql_result_free_result(wrapper);
-
-      wrapper->numberOfRows = wrapper->lastRowProcessed;
       wrapper->streamingComplete = 1;
 
       // Check for errors, the connection might have gone out from under us
@@ -554,6 +524,15 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
       rb_raise(cMysql2Error, "You have already fetched all the rows for this query and streaming is true. (to reiterate you must requery).");
     }
   } else {
+    if (wrapper->lastRowProcessed == 0) {
+      wrapper->numberOfRows = mysql_num_rows(wrapper->result);
+      if (wrapper->numberOfRows == 0) {
+        wrapper->rows = rb_ary_new();
+        return wrapper->rows;
+      }
+      wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
+    }
+
     if (cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) {
       /* we've already read the entire dataset from the C result into our */
       /* internal array. Lets hand that over to the user since it's ready to go */
@@ -598,17 +577,19 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 }
 
 static VALUE rb_mysql_result_count(VALUE self) {
-  mysql2_result_wrapper *wrapper;
+  GET_RESULT(self);
 
-  GetMysql2Result(self, wrapper);
-  if(wrapper->resultFreed) {
-    if (wrapper->streamingComplete){
-      return LONG2NUM(wrapper->numberOfRows);
-    } else {
-      return LONG2NUM(RARRAY_LEN(wrapper->rows));
-    }
+  if (wrapper->is_streaming) {
+    /* This is an unsigned long per result.h */
+    return ULONG2NUM(wrapper->numberOfRows);
+  }
+
+  if (wrapper->resultFreed) {
+    /* Ruby arrays have platform signed long length */
+    return LONG2NUM(RARRAY_LEN(wrapper->rows));
   } else {
-    return INT2FIX(mysql_num_rows(wrapper->result));
+    /* MySQL returns an unsigned 64-bit long here */
+    return ULL2NUM(mysql_num_rows(wrapper->result));
   }
 }
 
@@ -616,6 +597,7 @@ static VALUE rb_mysql_result_count(VALUE self) {
 VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_RES *r) {
   VALUE obj;
   mysql2_result_wrapper * wrapper;
+
   obj = Data_Make_Struct(cMysql2Result, mysql2_result_wrapper, rb_mysql_result_mark, rb_mysql_result_free, wrapper);
   wrapper->numberOfFields = 0;
   wrapper->numberOfRows = 0;
@@ -634,6 +616,10 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
 
   rb_iv_set(obj, "@query_options", options);
 
+  /* Options that cannot be changed in results.each(...) { |row| }
+   * should be processed here. */
+  wrapper->is_streaming = (rb_hash_aref(options, sym_stream) == Qtrue ? 1 : 0);
+
   return obj;
 }
 

data/ext/mysql2/result.h

@@ -12,12 +12,11 @@ typedef struct {
   unsigned int numberOfFields;
   unsigned long numberOfRows;
   unsigned long lastRowProcessed;
+  char is_streaming;
   char streamingComplete;
   char resultFreed;
   MYSQL_RES *result;
   mysql_client_wrapper *client_wrapper;
 } mysql2_result_wrapper;
 
-#define GetMysql2Result(obj, sval) (sval = (mysql2_result_wrapper*)DATA_PTR(obj));
-
 #endif

data/lib/mysql2/client.rb

@@ -82,6 +82,10 @@ module Mysql2
       info_hash
     end
 
+    def info
+      self.class.info
+    end
+
     private
       def self.local_offset
         ::Time.local(2010).utc_offset.to_r / 86400

data/lib/mysql2/em.rb

@@ -10,6 +10,7 @@ module Mysql2
         def initialize(client, deferable)
           @client = client
           @deferable = deferable
+          @is_watching = true
         end
 
         def notify_readable
@@ -22,11 +23,19 @@ module Mysql2
             @deferable.succeed(result)
           end
         end
+
+        def watching?
+          @is_watching
+        end
+
+        def unbind
+          @is_watching = false
+        end
       end
 
       def close(*args)
         if @watch
-          @watch.detach
+          @watch.detach if @watch.watching?
         end
         super(*args)
       end

data/lib/mysql2/error.rb

@@ -30,7 +30,7 @@ module Mysql2
     # variable.
     #
     # See http://dev.mysql.com/doc/refman/5.5/en/charset-errors.html for
-    # more contetx.
+    # more context.
     #
     # Before MySQL 5.5 error message template strings are in whatever encoding
     # is associated with the error message language.

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.3.17"
+  VERSION = "0.3.20"
 end

data/lib/mysql2.rb

@@ -3,6 +3,29 @@ require 'date'
 require 'bigdecimal'
 require 'rational' unless RUBY_VERSION >= '1.9.2'
 
+# Load libmysql.dll before requiring mysql2/mysql2.so
+# This gives a chance to be flexible about the load path
+# Or to bomb out with a clear error message instead of a linker crash
+if RUBY_PLATFORM =~ /mswin|mingw/
+  dll_path = if ENV['RUBY_MYSQL2_LIBMYSQL_DLL']
+               # If this environment variable is set, it overrides any other paths
+               # The user is advised to use backslashes not forward slashes
+               ENV['RUBY_MYSQL2_LIBMYSQL_DLL'].dup
+             elsif File.exist?(File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)))
+               # Use vendor/libmysql.dll if it exists, convert slashes for Win32 LoadLibrary
+               File.expand_path('../vendor/libmysql.dll', File.dirname(__FILE__)).gsub('/', '\\')
+             else
+               # This will use default / system library paths
+               'libmysql.dll'
+             end
+
+  require 'Win32API'
+  LoadLibrary = Win32API.new('Kernel32', 'LoadLibrary', ['P'], 'I')
+  if 0 == LoadLibrary.call(dll_path)
+    abort "Failed to load libmysql.dll from #{dll_path}"
+  end
+end
+
 require 'mysql2/version' unless defined? Mysql2::VERSION
 require 'mysql2/error'
 require 'mysql2/mysql2'

data/spec/em/em_spec.rb

@@ -108,6 +108,27 @@ begin
         callbacks_run.should == [:errback]
       end
     end
+
+    it "should not raise error when closing client with no query running" do
+      callbacks_run = []
+      EM.run do
+        client = Mysql2::EM::Client.new DatabaseCredentials['root']
+        defer = client.query("select sleep(0.025)")
+        defer.callback do |result|
+          callbacks_run << :callback
+        end
+        defer.errback do |err|
+          callbacks_run << :errback
+        end
+        EM.add_timer(0.1) do
+          callbacks_run.should == [:callback]
+          lambda {
+            client.close
+          }.should_not raise_error(/invalid binding to detach/)
+          EM.stop_event_loop
+        end
+      end
+    end
   end
 rescue LoadError
   puts "EventMachine not installed, skipping the specs that use it"

data/spec/mysql2/client_spec.rb

@@ -66,12 +66,13 @@ describe Mysql2::Client do
       end
     end
     client = klient.new
-    (client.connect_args.last[6] & (Mysql2::Client::REMEMBER_OPTIONS |
-                                     Mysql2::Client::LONG_PASSWORD |
-                                     Mysql2::Client::LONG_FLAG |
-                                     Mysql2::Client::TRANSACTIONS |
-                                     Mysql2::Client::PROTOCOL_41 |
-                                     Mysql2::Client::SECURE_CONNECTION)).should be_true
+    client_flags = Mysql2::Client::REMEMBER_OPTIONS |
+                   Mysql2::Client::LONG_PASSWORD |
+                   Mysql2::Client::LONG_FLAG |
+                   Mysql2::Client::TRANSACTIONS |
+                   Mysql2::Client::PROTOCOL_41 |
+                   Mysql2::Client::SECURE_CONNECTION
+    client.connect_args.last[6].should eql(client_flags)
   end
 
   it "should execute init command" do
@@ -564,7 +565,7 @@ describe Mysql2::Client do
       end
 
       it "should raise an exception when one of multiple statements fails" do
-        result = @multi_client.query("SELECT 1 as 'set_1'; SELECT * FROM invalid_table_name;SELECT 2 as 'set_2';")
+        result = @multi_client.query("SELECT 1 AS 'set_1'; SELECT * FROM invalid_table_name; SELECT 2 AS 'set_2';")
         result.first['set_1'].should be(1)
         lambda {
           @multi_client.next_result
@@ -573,7 +574,7 @@ describe Mysql2::Client do
       end
 
       it "returns multiple result sets" do
-        @multi_client.query( "select 1 as 'set_1'; select 2 as 'set_2'").first.should eql({ 'set_1' => 1 })
+        @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'").first.should eql({ 'set_1' => 1 })
 
         @multi_client.next_result.should be_true
         @multi_client.store_result.first.should eql({ 'set_2' => 2 })
@@ -582,12 +583,12 @@ describe Mysql2::Client do
       end
 
       it "does not interfere with other statements" do
-        @multi_client.query( "select 1 as 'set_1'; select 2 as 'set_2'")
+        @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'")
         while( @multi_client.next_result )
           @multi_client.store_result
         end
 
-        @multi_client.query( "select 3 as 'next'").first.should == { 'next' => 3 }
+        @multi_client.query("SELECT 3 AS 'next'").first.should == { 'next' => 3 }
       end
 
       it "will raise on query if there are outstanding results to read" do
@@ -606,7 +607,7 @@ describe Mysql2::Client do
       end
 
       it "#more_results? should work" do
-        @multi_client.query( "select 1 as 'set_1'; select 2 as 'set_2'")
+        @multi_client.query("SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'")
         @multi_client.more_results?.should be_true
 
         @multi_client.next_result
@@ -614,6 +615,21 @@ describe Mysql2::Client do
 
         @multi_client.more_results?.should be_false
       end
+
+      it "#more_results? should work with stored procedures" do
+        @multi_client.query("DROP PROCEDURE IF EXISTS test_proc")
+        @multi_client.query("CREATE PROCEDURE test_proc() BEGIN SELECT 1 AS 'set_1'; SELECT 2 AS 'set_2'; END")
+        @multi_client.query("CALL test_proc()").first.should eql({ 'set_1' => 1 })
+        @multi_client.more_results?.should be_true
+
+        @multi_client.next_result
+        @multi_client.store_result.first.should eql({ 'set_2' => 2 })
+
+        @multi_client.next_result
+        @multi_client.store_result.should be_nil # this is the result from CALL itself
+
+        @multi_client.more_results?.should be_false
+      end
     end
   end
 
@@ -700,6 +716,19 @@ describe Mysql2::Client do
         @client.escape ""
       }.should raise_error(Mysql2::Error)
     end
+
+    context 'when mysql encoding is not utf8' do
+      before { pending('Encoding is undefined') unless defined?(Encoding) }
+
+      let(:client) { Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => "ujis")) }
+
+      it 'should return a internal encoding string if Encoding.default_internal is set' do
+        with_internal_encoding Encoding::UTF_8 do
+          client.escape("\u{30C6}\u{30B9}\u{30C8}").should eql("\u{30C6}\u{30B9}\u{30C8}")
+          client.escape("\u{30C6}'\u{30B9}\"\u{30C8}").should eql("\u{30C6}\\'\u{30B9}\\\"\u{30C8}")
+        end
+      end
+    end
   end
 
   it "should respond to #info" do
@@ -715,26 +744,21 @@ describe Mysql2::Client do
     info[:version].class.should eql(String)
   end
 
-  if defined? Encoding
-    context "strings returned by #info" do
-      it "should default to the connection's encoding if Encoding.default_internal is nil" do
-        with_internal_encoding nil do
-          @client.info[:version].encoding.should eql(Encoding.find('utf-8'))
+  context "strings returned by #info" do
+    before { pending('Encoding is undefined') unless defined?(Encoding) }
 
-          client2 = Mysql2::Client.new(DatabaseCredentials['root'].merge(:encoding => 'ascii'))
-          client2.info[:version].encoding.should eql(Encoding.find('us-ascii'))
-        end
-      end
+    it "should be tagged as ascii" do
+      @client.info[:version].encoding.should eql(Encoding::US_ASCII)
+      @client.info[:header_version].encoding.should eql(Encoding::US_ASCII)
+    end
+  end
 
-      it "should use Encoding.default_internal" do
-        with_internal_encoding 'utf-8' do
-          @client.info[:version].encoding.should eql(Encoding.default_internal)
-        end
+  context "strings returned by .info" do
+    before { pending('Encoding is undefined') unless defined?(Encoding) }
 
-        with_internal_encoding 'us-ascii' do
-          @client.info[:version].encoding.should eql(Encoding.default_internal)
-        end
-      end
+    it "should be tagged as ascii" do
+      Mysql2::Client.info[:version].encoding.should eql(Encoding::US_ASCII)
+      Mysql2::Client.info[:header_version].encoding.should eql(Encoding::US_ASCII)
     end
   end
 

data/spec/mysql2/result_spec.rb

@@ -6,6 +6,14 @@ describe Mysql2::Result do
     @result = @client.query "SELECT 1"
   end
 
+  it "should raise a TypeError exception when it doesn't wrap a result set" do
+    r = Mysql2::Result.new
+    expect { r.count }.to raise_error(TypeError)
+    expect { r.fields }.to raise_error(TypeError)
+    expect { r.size }.to raise_error(TypeError)
+    expect { r.each }.to raise_error(TypeError)
+  end
+
   it "should have included Enumerable" do
     Mysql2::Result.ancestors.include?(Enumerable).should be_true
   end
@@ -107,18 +115,19 @@ describe Mysql2::Result do
 
   context "streaming" do
     it "should maintain a count while streaming" do
-      result = @client.query('SELECT 1')
-
-      result.count.should eql(1)
+      result = @client.query('SELECT 1', :stream => true, :cache_rows => false)
+      result.count.should eql(0)
       result.each.to_a
       result.count.should eql(1)
     end
 
-    it "should set the actual count of rows after streaming" do
-      result = @client.query("SELECT * FROM mysql2_test", :stream => true, :cache_rows => false)
+    it "should retain the count when mixing first and each" do
+      result = @client.query("SELECT 1 UNION SELECT 2", :stream => true, :cache_rows => false)
       result.count.should eql(0)
-      result.each {|r|  }
+      result.first
       result.count.should eql(1)
+      result.each.to_a
+      result.count.should eql(2)
     end
 
     it "should not yield nil at the end of streaming" do
@@ -136,7 +145,7 @@ describe Mysql2::Result do
     it "should raise an exception if streaming ended due to a timeout" do
       # Create an extra client instance, since we're going to time it out
       client = Mysql2::Client.new DatabaseCredentials['root']
-      client.query "CREATE TEMPORARY TABLE streamingTest (val BINARY(255))"
+      client.query "CREATE TEMPORARY TABLE streamingTest (val BINARY(255)) ENGINE=MEMORY"
 
       # Insert enough records to force the result set into multiple reads
       # (the BINARY type is used simply because it forces full width results)