mysql2 0.3.11 → 0.3.12b1

data/ext/mysql2/client.h

@@ -33,10 +33,12 @@ void init_mysql2_client();
 
 typedef struct {
   VALUE encoding;
-  int active;
+  VALUE active_thread; /* rb_thread_current() or Qnil */
   int reconnect_enabled;
-  int closed;
+  int active;
+  int connected;
+  int initialized;
   MYSQL *client;
 } mysql_client_wrapper;
 
-#endif
+#endif

data/ext/mysql2/extconf.rb

@@ -17,6 +17,7 @@ dirs = ENV['PATH'].split(File::PATH_SEPARATOR) + %w[
   /opt/local/mysql
   /opt/local/lib/mysql5
   /usr
+  /usr/mysql
   /usr/local
   /usr/local/mysql
   /usr/local/mysql-*
@@ -61,13 +62,13 @@ end
   asplode h unless have_header h
 end
 
-unless RUBY_PLATFORM =~ /mswin/ or RUBY_PLATFORM =~ /sparc/
+# GCC specific flags
+if RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
   $CFLAGS << ' -Wall -funroll-loops'
-end
-# $CFLAGS << ' -O0 -ggdb3 -Wextra'
 
-if hard_mysql_path = $libs[%r{-L(/[^ ]+)}, 1]
-	$LDFLAGS << " -Wl,-rpath,#{hard_mysql_path}"
+  if hard_mysql_path = $libs[%r{-L(/[^ ]+)}, 1]
+    $LDFLAGS << " -Wl,-rpath,#{hard_mysql_path}"
+  end
 end
 
 create_makefile('mysql2/mysql2')

data/ext/mysql2/result.c

@@ -55,7 +55,7 @@ static VALUE intern_encoding_from_charset;
 static ID intern_new, intern_utc, intern_local, intern_encoding_from_charset_code,
           intern_localtime, intern_local_offset, intern_civil, intern_new_offset;
 static VALUE sym_symbolize_keys, sym_as, sym_array, sym_database_timezone, sym_application_timezone,
-          sym_local, sym_utc, sym_cast_booleans, sym_cache_rows, sym_cast;
+          sym_local, sym_utc, sym_cast_booleans, sym_cache_rows, sym_cast, sym_stream;
 static ID intern_merge;
 
 static void rb_mysql_result_mark(void * wrapper) {
@@ -163,11 +163,10 @@ static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_e
 #endif
 
 
-static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast) {
+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;
-  MYSQL_FIELD * fields = NULL;
   unsigned int i = 0;
   unsigned long * fieldLengths;
   void * ptr;
@@ -193,7 +192,6 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
   } else {
     rowVal = rb_hash_new();
   }
-  fields = mysql_fetch_fields(wrapper->result);
   fieldLengths = mysql_fetch_lengths(wrapper->result);
   if (wrapper->fields == Qnil) {
     wrapper->numberOfFields = mysql_num_fields(wrapper->result);
@@ -225,7 +223,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
           break;
         case MYSQL_TYPE_TINY:       // TINYINT field
           if (castBool && fields[i].length == 1) {
-            val = *row[i] == '1' ? Qtrue : Qfalse;
+            val = *row[i] != '0' ? Qtrue : Qfalse;
             break;
           }
         case MYSQL_TYPE_SHORT:      // SMALLINT field
@@ -237,7 +235,9 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
           break;
         case MYSQL_TYPE_DECIMAL:    // DECIMAL or NUMERIC field
         case MYSQL_TYPE_NEWDECIMAL: // Precision math DECIMAL or NUMERIC field (MySQL 5.0.3 and up)
-          if (strtod(row[i], NULL) == 0.000000){
+          if (fields[i].decimals == 0) {
+            val = rb_cstr2inum(row[i], 10);
+          } else if (strtod(row[i], NULL) == 0.000000){
             val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero);
           }else{
             val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i]));
@@ -392,7 +392,8 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   ID db_timezone, app_timezone, dbTz, appTz;
   mysql2_result_wrapper * wrapper;
   unsigned long i;
-  int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1;
+  int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1, streaming = 0;
+  MYSQL_FIELD * fields = NULL;
 
   GetMysql2Result(self, wrapper);
 
@@ -423,6 +424,14 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     cast = 0;
   }
 
+  if(rb_hash_aref(opts, sym_stream) == Qtrue) {
+    streaming = 1;
+  }
+
+  if(streaming && cacheRows) {
+    rb_warn("cacheRows is ignored if streaming is true");
+  }
+
   dbTz = rb_hash_aref(opts, sym_database_timezone);
   if (dbTz == sym_local) {
     db_timezone = intern_local;
@@ -445,49 +454,82 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   }
 
   if (wrapper->lastRowProcessed == 0) {
-    wrapper->numberOfRows = mysql_num_rows(wrapper->result);
-    if (wrapper->numberOfRows == 0) {
+    if(streaming) {
+      // We can't get number of rows if we're streaming,
+      // until we've finished fetching all rows
+      wrapper->numberOfRows = 0;
       wrapper->rows = rb_ary_new();
-      return wrapper->rows;
+    } 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);
     }
-    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
-    for (i = 0; i < wrapper->numberOfRows; i++) {
-      rb_yield(rb_ary_entry(wrapper->rows, i));
-    }
-  } else {
-    unsigned long rowsProcessed = 0;
-    rowsProcessed = RARRAY_LEN(wrapper->rows);
-    for (i = 0; i < wrapper->numberOfRows; i++) {
+  if (streaming) {
+    if(!wrapper->streamingComplete) {
       VALUE row;
-      if (cacheRows && i < rowsProcessed) {
-        row = rb_ary_entry(wrapper->rows, i);
-      } else {
-        row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast);
-        if (cacheRows) {
-          rb_ary_store(wrapper->rows, i, row);
+
+      fields = mysql_fetch_fields(wrapper->result);
+
+      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++;
         }
-        wrapper->lastRowProcessed++;
+      } while(row != Qnil);
+
+      rb_mysql_result_free_result(wrapper);
+
+      wrapper->numberOfRows = wrapper->lastRowProcessed;
+      wrapper->streamingComplete = 1;
+    } else {
+      rb_raise(cMysql2Error, "You have already fetched all the rows for this query and streaming is true. (to reiterate you must requery).");
+    }
+  } else {
+    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
+      for (i = 0; i < wrapper->numberOfRows; i++) {
+        rb_yield(rb_ary_entry(wrapper->rows, i));
       }
+    } else {
+      unsigned long rowsProcessed = 0;
+      rowsProcessed = RARRAY_LEN(wrapper->rows);
+      fields = mysql_fetch_fields(wrapper->result);
+
+      for (i = 0; i < wrapper->numberOfRows; i++) {
+        VALUE row;
+        if (cacheRows && i < rowsProcessed) {
+          row = rb_ary_entry(wrapper->rows, i);
+        } else {
+          row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields);
+          if (cacheRows) {
+            rb_ary_store(wrapper->rows, i, row);
+          }
+          wrapper->lastRowProcessed++;
+        }
 
-      if (row == Qnil) {
+        if (row == Qnil) {
+          // we don't need the mysql C dataset around anymore, peace it
+          rb_mysql_result_free_result(wrapper);
+          return Qnil;
+        }
+
+        if (block != Qnil) {
+          rb_yield(row);
+        }
+      }
+      if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
         // we don't need the mysql C dataset around anymore, peace it
         rb_mysql_result_free_result(wrapper);
-        return Qnil;
-      }
-
-      if (block != Qnil) {
-        rb_yield(row);
       }
     }
-    if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
-      // we don't need the mysql C dataset around anymore, peace it
-      rb_mysql_result_free_result(wrapper);
-    }
   }
 
   return wrapper->rows;
@@ -497,8 +539,15 @@ static VALUE rb_mysql_result_count(VALUE self) {
   mysql2_result_wrapper *wrapper;
 
   GetMysql2Result(self, wrapper);
-
-  return INT2FIX(mysql_num_rows(wrapper->result));
+  if(wrapper->resultFreed) {
+    if (wrapper->streamingComplete){
+      return LONG2NUM(wrapper->numberOfRows);
+    } else {
+      return LONG2NUM(RARRAY_LEN(wrapper->rows));
+    }
+  } else {
+    return INT2FIX(mysql_num_rows(wrapper->result));
+  }
 }
 
 /* Mysql2::Result */
@@ -514,6 +563,7 @@ VALUE rb_mysql_result_to_obj(MYSQL_RES * r) {
   wrapper->fields = Qnil;
   wrapper->rows = Qnil;
   wrapper->encoding = Qnil;
+  wrapper->streamingComplete = 0;
   rb_obj_call_init(obj, 0, NULL);
   return obj;
 }
@@ -551,6 +601,7 @@ void init_mysql2_result() {
   sym_application_timezone  = ID2SYM(rb_intern("application_timezone"));
   sym_cache_rows     = ID2SYM(rb_intern("cache_rows"));
   sym_cast           = ID2SYM(rb_intern("cast"));
+  sym_stream         = ID2SYM(rb_intern("stream"));
 
   opt_decimal_zero = rb_str_new2("0.0");
   rb_global_variable(&opt_decimal_zero); //never GC

data/ext/mysql2/result.h

@@ -11,6 +11,7 @@ typedef struct {
   unsigned int numberOfFields;
   unsigned long numberOfRows;
   unsigned long lastRowProcessed;
+  char streamingComplete;
   char resultFreed;
   MYSQL_RES *result;
 } mysql2_result_wrapper;

data/lib/mysql2.rb

@@ -16,6 +16,22 @@ module Mysql2
 end
 
 if defined?(ActiveRecord::VERSION::STRING) && ActiveRecord::VERSION::STRING < "3.1"
-  puts "WARNING: This version of mysql2 (#{Mysql2::VERSION}) doesn't ship with the ActiveRecord adapter bundled anymore as it's now part of Rails 3.1"
-  puts "WARNING: Please use the 0.2.x releases if you plan on using it in Rails <= 3.0.x"
+  warn "============= WARNING FROM mysql2 ============="
+  warn "This version of mysql2 (#{Mysql2::VERSION}) doesn't ship with the ActiveRecord adapter."
+  warn "In Rails version 3.1.0 and up, the mysql2 ActiveRecord adapter is included with rails."
+  warn "If you want to use the mysql2 gem with Rails <= 3.0.x, please use the latest mysql2 in the 0.2.x series."
+  warn "============= END WARNING FROM mysql2 ============="
+end
+
+# For holding utility methods
+module Mysql2::Util
+
+  #
+  # Rekey a string-keyed hash with equivalent symbols.
+  #
+  def self.key_hash_as_symbols(hash)
+    return nil unless hash
+    Hash[hash.map { |k,v| [k.to_sym, v] }]
+  end
+	
 end

data/lib/mysql2/client.rb

@@ -14,31 +14,36 @@ module Mysql2
     }
 
     def initialize(opts = {})
+      opts = Mysql2::Util.key_hash_as_symbols( opts )
       @query_options = @@default_query_options.dup
       @query_options.merge! opts
 
-      init_connection
+      initialize_ext
 
-      [:reconnect, :connect_timeout].each do |key|
+      # Set MySQL connection options (each one is a call to mysql_options())
+      [:reconnect, :connect_timeout, :local_infile, :read_timeout].each do |key|
         next unless opts.key?(key)
         send(:"#{key}=", opts[key])
       end
+
       # force the encoding to utf8
       self.charset_name = opts[:encoding] || 'utf8'
 
-      @read_timeout = opts[:read_timeout]
-      if @read_timeout and @read_timeout < 0
-        raise Mysql2::Error, "read_timeout must be a positive integer, you passed #{@read_timeout}"
-      end
-
       ssl_set(*opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher))
+      
+      if [:user,:pass,:hostname,:dbname,:db,:sock].any?{|k| @query_options.has_key?(k) }
+        warn "============= WARNING FROM mysql2 ============="
+        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock will be deprecated at some point in the future."
+        warn "Instead, please use :username, :password, :host, 'localhost', :port, :database, :socket, :flags for the options."
+        warn "============= END WARNING FROM mysql2 ========="
+      end
 
-      user     = opts[:username]
-      pass     = opts[:password]
-      host     = opts[:host] || 'localhost'
+      user     = opts[:username] || opts[:user]
+      pass     = opts[:password] || opts[:pass]
+      host     = opts[:host] || opts[:hostname] || 'localhost'
       port     = opts[:port] || 3306
-      database = opts[:database]
-      socket   = opts[:socket]
+      database = opts[:database] || opts[:dbname] || opts[:db]
+      socket   = opts[:socket] || opts[:sock]
       flags    = opts[:flags] ? opts[:flags] | @query_options[:connect_flags] : @query_options[:connect_flags]
 
       connect user, pass, host, port, database, socket, flags
@@ -87,6 +92,7 @@ module Mysql2
         "ucs2"     => Encoding::UTF_16BE,
         "ujis"     => Encoding::EucJP_ms,
         "utf8"     => Encoding::UTF_8,
+        "utf8mb4"  => Encoding::UTF_8,
       }
 
       MYSQL_CHARSET_MAP = {
@@ -134,6 +140,8 @@ module Mysql2
         42 => {:name => "latin7",   :collation => "latin7_general_cs"},
         43 => {:name => "macce",    :collation => "macce_bin"},
         44 => {:name => "cp1250",   :collation => "cp1250_croatian_ci"},
+        45 => {:name => "utf8mb4",  :collation => "utf8mb4_general_ci"},
+        46 => {:name => "utf8mb4",  :collation => "utf8mb4_bin"},
         47 => {:name => "latin1",   :collation => "latin1_bin"},
         48 => {:name => "latin1",   :collation => "latin1_general_ci"},
         49 => {:name => "latin1",   :collation => "latin1_general_cs"},
@@ -218,6 +226,25 @@ module Mysql2
         208 => {:name => "utf8",    :collation => "utf8_persian_ci"},
         209 => {:name => "utf8",    :collation => "utf8_esperanto_ci"},
         210 => {:name => "utf8",    :collation => "utf8_hungarian_ci"},
+        224 => {:name => "utf8mb4", :collation => "utf8mb4_unicode_ci"},
+        225 => {:name => "utf8mb4", :collation => "utf8mb4_icelandic_ci"},
+        226 => {:name => "utf8mb4", :collation => "utf8mb4_latvian_ci"},
+        227 => {:name => "utf8mb4", :collation => "utf8mb4_romanian_ci"},
+        228 => {:name => "utf8mb4", :collation => "utf8mb4_slovenian_ci"},
+        229 => {:name => "utf8mb4", :collation => "utf8mb4_polish_ci"},
+        230 => {:name => "utf8mb4", :collation => "utf8mb4_estonian_ci"},
+        231 => {:name => "utf8mb4", :collation => "utf8mb4_spanish_ci"},
+        232 => {:name => "utf8mb4", :collation => "utf8mb4_swedish_ci"},
+        233 => {:name => "utf8mb4", :collation => "utf8mb4_turkish_ci"},
+        234 => {:name => "utf8mb4", :collation => "utf8mb4_czech_ci"},
+        235 => {:name => "utf8mb4", :collation => "utf8mb4_danish_ci"},
+        236 => {:name => "utf8mb4", :collation => "utf8mb4_lithuanian_ci"},
+        237 => {:name => "utf8mb4", :collation => "utf8mb4_slovak_ci"},
+        238 => {:name => "utf8mb4", :collation => "utf8mb4_spanish2_ci"},
+        239 => {:name => "utf8mb4", :collation => "utf8mb4_roman_ci"},
+        240 => {:name => "utf8mb4", :collation => "utf8mb4_persian_ci"},
+        241 => {:name => "utf8mb4", :collation => "utf8mb4_esperanto_ci"},
+        242 => {:name => "utf8mb4", :collation => "utf8mb4_hungarian_ci"},
         254 => {:name => "utf8",    :collation => "utf8_general_cs"}
       }
 

data/lib/mysql2/em.rb

@@ -15,18 +15,28 @@ module Mysql2
         def notify_readable
           detach
           begin
-            @deferable.succeed(@client.async_result)
+            result = @client.async_result
           rescue Exception => e
             @deferable.fail(e)
+          else
+            @deferable.succeed(result)
           end
         end
       end
 
+      def close(*args)
+        if @watch
+          @watch.detach
+        end
+        super(*args)
+      end
+
       def query(sql, opts={})
         if ::EM.reactor_running?
           super(sql, opts.merge(:async => true))
           deferable = ::EM::DefaultDeferrable.new
-          ::EM.watch(self.socket, Watcher, self, deferable).notify_readable = true
+          @watch = ::EM.watch(self.socket, Watcher, self, deferable)
+          @watch.notify_readable = true
           deferable
         else
           super(sql, opts)
@@ -34,4 +44,4 @@ module Mysql2
       end
     end
   end
-end
+end

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.3.11"
+  VERSION = "0.3.12b1"
 end

data/spec/configuration.yml.example

@@ -0,0 +1,11 @@
+root:
+  host: localhost
+  username: root
+  password:
+  database: test
+
+user:
+  host: localhost
+  username: LOCALUSERNAME
+  password:
+  database: mysql2_test

data/spec/em/em_spec.rb

@@ -8,14 +8,14 @@ begin
     it "should support async queries" do
       results = []
       EM.run do
-        client1 = Mysql2::EM::Client.new
+        client1 = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer1 = client1.query "SELECT sleep(0.1) as first_query"
         defer1.callback do |result|
           results << result.first
           EM.stop_event_loop
         end
 
-        client2 = Mysql2::EM::Client.new
+        client2 = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer2 = client2.query "SELECT sleep(0.025) second_query"
         defer2.callback do |result|
           results << result.first
@@ -29,7 +29,7 @@ begin
     it "should support queries in callbacks" do
       results = []
       EM.run do
-        client = Mysql2::EM::Client.new
+        client = Mysql2::EM::Client.new DatabaseCredentials['root']
         defer1 = client.query "SELECT sleep(0.025) as first_query"
         defer1.callback do |result|
           results << result.first
@@ -44,6 +44,66 @@ begin
       results[0].keys.should include("first_query")
       results[1].keys.should include("second_query")
     end
+
+    it "should not swallow exceptions raised in callbacks" do
+      lambda {
+        EM.run do
+          client = Mysql2::EM::Client.new DatabaseCredentials['root']
+          defer = client.query "SELECT sleep(0.1) as first_query"
+          defer.callback do |result|
+            raise 'some error'
+          end
+          defer.errback do |err|
+            # This _shouldn't_ be run, but it needed to prevent the specs from
+            # freezing if this test fails.
+            EM.stop_event_loop
+          end
+        end
+      }.should raise_error
+    end
+
+    context 'when an exception is raised by the client' do
+      let(:client) { Mysql2::EM::Client.new DatabaseCredentials['root'] }
+      let(:error) { StandardError.new('some error') }
+      before { client.stub(:async_result).and_raise(error) }
+
+      it "should swallow exceptions raised in by the client" do
+        errors = []
+        EM.run do
+          defer = client.query "SELECT sleep(0.1) as first_query"
+          defer.callback do |result|
+            # This _shouldn't_ be run, but it is needed to prevent the specs from
+            # freezing if this test fails.
+            EM.stop_event_loop
+          end
+          defer.errback do |err|
+            errors << err
+            EM.stop_event_loop
+          end
+        end
+        errors.should == [error]
+      end
+
+      it "should fail the deferrable" do
+        callbacks_run = []
+        EM.run do
+          defer = client.query "SELECT sleep(0.025) as first_query"
+          EM.add_timer(0.1) do
+            defer.callback do |result|
+              callbacks_run << :callback
+              # This _shouldn't_ be run, but it is needed to prevent the specs from
+              # freezing if this test fails.
+              EM.stop_event_loop
+            end
+            defer.errback do |err|
+              callbacks_run << :errback
+              EM.stop_event_loop
+            end
+          end
+        end
+        callbacks_run.should == [:errback]
+      end
+    end
   end
 rescue LoadError
   puts "EventMachine not installed, skipping the specs that use it"