mysql2 0.2.6-x86-mingw32 → 0.2.16-x86-mingw32

data/ext/mysql2/client.h

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

data/ext/mysql2/extconf.rb

@@ -7,6 +7,7 @@ end
 
 # 1.9-only
 have_func('rb_thread_blocking_region')
+have_func('rb_wait_for_single_fd')
 
 # borrowed from mysqlplus
 # http://github.com/oldmoe/mysqlplus/blob/master/ext/extconf.rb
@@ -31,7 +32,10 @@ elsif mc = (with_config('mysql-config') || Dir[GLOB].first) then
   mc = Dir[GLOB].first if mc == true
   cflags = `#{mc} --cflags`.chomp
   exit 1 if $? != 0
-  libs = `#{mc} --libs`.chomp
+  libs = `#{mc} --libs_r`.chomp
+  if libs.empty?
+    libs = `#{mc} --libs`.chomp
+  end
   exit 1 if $? != 0
   $CPPFLAGS += ' ' + cflags
   $libs = libs + " " + $libs
@@ -62,4 +66,8 @@ unless RUBY_PLATFORM =~ /mswin/ or RUBY_PLATFORM =~ /sparc/
 end
 # $CFLAGS << ' -O0 -ggdb3 -Wextra'
 
+if hard_mysql_path = $libs[%r{-L(/[^ ]+)}, 1]
+	$LDFLAGS << " -Wl,-rpath,#{hard_mysql_path}"
+end
+
 create_makefile('mysql2/mysql2')

data/ext/mysql2/mysql2_ext.h

@@ -1,9 +1,19 @@
 #ifndef MYSQL2_EXT
 #define MYSQL2_EXT
 
+// tell rbx not to use it's caching compat layer
+// by doing this we're making a promize to RBX that
+// we'll never modify the pointers we get back from RSTRING_PTR
+#define RSTRING_NOT_MODIFIED
 #include <ruby.h>
 #include <fcntl.h>
 
+#ifndef HAVE_UINT
+#define HAVE_UINT
+typedef unsigned short    ushort;
+typedef unsigned int    uint;
+#endif
+
 #ifdef HAVE_MYSQL_H
 #include <mysql.h>
 #include <mysql_com.h>

data/ext/mysql2/result.c

@@ -1,18 +1,61 @@
 #include <mysql2_ext.h>
+#include <stdint.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
-rb_encoding *binaryEncoding;
+static rb_encoding *binaryEncoding;
 #endif
 
-VALUE cMysql2Result;
-VALUE cBigDecimal, cDate, cDateTime;
-VALUE opt_decimal_zero, opt_float_zero, opt_time_year, opt_time_month, opt_utc_offset;
+#if (SIZEOF_INT < SIZEOF_LONG) || defined(HAVE_RUBY_ENCODING_H)
+/* on 64bit platforms we can handle dates way outside 2038-01-19T03:14:07
+ *
+ * (9999*31557600) + (12*2592000) + (31*86400) + (11*3600) + (59*60) + 59
+ */
+#define MYSQL2_MAX_TIME 315578267999ULL
+#else
+/**
+ * On 32bit platforms the maximum date the Time class can handle is 2038-01-19T03:14:07
+ * 2038 years + 1 month + 19 days + 3 hours + 14 minutes + 7 seconds = 64318634047 seconds
+ *
+ * (2038*31557600) + (1*2592000) + (19*86400) + (3*3600) + (14*60) + 7
+ */
+#define MYSQL2_MAX_TIME 64318634047ULL
+#endif
+
+#if defined(HAVE_RUBY_ENCODING_H)
+/* 0000-1-1 00:00:00 UTC
+ *
+ * (0*31557600) + (1*2592000) + (1*86400) + (0*3600) + (0*60) + 0
+ */
+#define MYSQL2_MIN_TIME 2678400ULL
+#elif SIZEOF_INT < SIZEOF_LONG // 64bit Ruby 1.8
+/* 0139-1-1 00:00:00 UTC
+ *
+ * (139*31557600) + (1*2592000) + (1*86400) + (0*3600) + (0*60) + 0
+ */
+#define MYSQL2_MIN_TIME 4389184800ULL
+#elif defined(NEGATIVE_TIME_T)
+/* 1901-12-13 20:45:52 UTC : The oldest time in 32-bit signed time_t.
+ *
+ * (1901*31557600) + (12*2592000) + (13*86400) + (20*3600) + (45*60) + 52
+ */
+#define MYSQL2_MIN_TIME 60023299552ULL
+#else
+/* 1970-01-01 00:00:01 UTC : The Unix epoch - the oldest time in portable time_t.
+ *
+ * (1970*31557600) + (1*2592000) + (1*86400) + (0*3600) + (0*60) + 1
+ */
+#define MYSQL2_MIN_TIME 62171150401ULL
+#endif
+
+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;
 extern VALUE mMysql2, cMysql2Client, cMysql2Error;
 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 ID sym_symbolize_keys, sym_as, sym_array, sym_database_timezone, sym_application_timezone,
-          sym_local, sym_utc, sym_cast_booleans, sym_cache_rows;
+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;
 static ID intern_merge;
 
 static void rb_mysql_result_mark(void * wrapper) {
@@ -53,7 +96,7 @@ static VALUE 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);
 
   if (wrapper->fields == Qnil) {
@@ -61,7 +104,7 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int
     wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
   }
 
-  VALUE rb_field = rb_ary_entry(wrapper->fields, idx);
+  rb_field = rb_ary_entry(wrapper->fields, idx);
   if (rb_field == Qnil) {
     MYSQL_FIELD *field = NULL;
 #ifdef HAVE_RUBY_ENCODING_H
@@ -71,10 +114,15 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int
 
     field = mysql_fetch_field_direct(wrapper->result, idx);
     if (symbolize_keys) {
+      VALUE colStr;
       char buf[field->name_length+1];
       memcpy(buf, field->name, field->name_length);
       buf[field->name_length] = 0;
-      rb_field = ID2SYM(rb_intern(buf));
+      colStr = rb_str_new2(buf);
+#ifdef HAVE_RUBY_ENCODING_H
+      rb_enc_associate(colStr, rb_utf8_encoding());
+#endif
+      rb_field = ID2SYM(rb_to_id(colStr));
     } else {
       rb_field = rb_str_new(field->name, field->name_length);
 #ifdef HAVE_RUBY_ENCODING_H
@@ -90,7 +138,32 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int
   return rb_field;
 }
 
-static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool) {
+#ifdef HAVE_RUBY_ENCODING_H
+static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_encoding *default_internal_enc, rb_encoding *conn_enc) {
+  // if binary flag is set, respect it's wishes
+  if (field.flags & BINARY_FLAG && field.charsetnr == 63) {
+    rb_enc_associate(val, binaryEncoding);
+  } else {
+    // lookup the encoding configured on this field
+    VALUE new_encoding = rb_funcall(cMysql2Client, intern_encoding_from_charset_code, 1, INT2NUM(field.charsetnr));
+    if (new_encoding != Qnil) {
+      // use the field encoding we were able to match
+      rb_encoding *enc = rb_to_encoding(new_encoding);
+      rb_enc_associate(val, enc);
+    } else {
+      // otherwise fall-back to the connection's encoding
+      rb_enc_associate(val, conn_enc);
+    }
+    if (default_internal_enc) {
+      val = rb_str_export_to_enc(val, default_internal_enc);
+    }
+  }
+  return val;
+}
+#endif
+
+
+static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast) {
   VALUE rowVal;
   mysql2_result_wrapper * wrapper;
   MYSQL_ROW row;
@@ -98,12 +171,15 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
   unsigned int i = 0;
   unsigned long * fieldLengths;
   void * ptr;
-
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+  rb_encoding *conn_enc;
+#endif
   GetMysql2Result(self, 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
 
   ptr = wrapper->result;
@@ -128,7 +204,19 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
     VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys);
     if (row[i]) {
       VALUE val = Qnil;
-      switch(fields[i].type) {
+      enum enum_field_types type = fields[i].type;
+
+      if(!cast) {
+        if (type == MYSQL_TYPE_NULL) {
+          val = Qnil;
+        } else {
+          val = rb_str_new(row[i], fieldLengths[i]);
+#ifdef HAVE_RUBY_ENCODING_H
+          val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc);
+#endif
+        }
+      } else {
+        switch(type) {
         case MYSQL_TYPE_NULL:       // NULL-type field
           val = Qnil;
           break;
@@ -181,16 +269,20 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
         }
         case MYSQL_TYPE_TIMESTAMP:  // TIMESTAMP field
         case MYSQL_TYPE_DATETIME: { // DATETIME field
-          int year, month, day, hour, min, sec, tokens;
+          unsigned int year, month, day, hour, min, sec, tokens;
+          uint64_t seconds;
+
           tokens = sscanf(row[i], "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec);
-          if (year+month+day+hour+min+sec == 0) {
+          seconds = (year*31557600ULL) + (month*2592000ULL) + (day*86400ULL) + (hour*3600ULL) + (min*60ULL) + sec;
+
+          if (seconds == 0) {
             val = Qnil;
           } else {
             if (month < 1 || day < 1) {
               rb_raise(cMysql2Error, "Invalid date: %s", row[i]);
               val = Qnil;
             } else {
-              if (year < 1902 || year+month+day > 2058) { // use DateTime instead
+              if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { // use DateTime instead
                 VALUE offset = INT2NUM(0);
                 if (db_timezone == intern_local) {
                   offset = rb_funcall(cMysql2Client, intern_local_offset, 0);
@@ -247,26 +339,10 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
         default:
           val = rb_str_new(row[i], fieldLengths[i]);
 #ifdef HAVE_RUBY_ENCODING_H
-          // if binary flag is set, respect it's wishes
-          if (fields[i].flags & BINARY_FLAG) {
-            rb_enc_associate(val, binaryEncoding);
-          } else {
-            // lookup the encoding configured on this field
-            VALUE new_encoding = rb_funcall(cMysql2Client, intern_encoding_from_charset_code, 1, INT2NUM(fields[i].charsetnr));
-            if (new_encoding != Qnil) {
-              // use the field encoding we were able to match
-              rb_encoding *enc = rb_to_encoding(new_encoding);
-              rb_enc_associate(val, enc);
-            } else {
-              // otherwise fall-back to the connection's encoding
-              rb_enc_associate(val, conn_enc);
-            }
-            if (default_internal_enc) {
-              val = rb_str_export_to_enc(val, default_internal_enc);
-            }
-          }
+          val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc);
 #endif
           break;
+        }
       }
       if (asArray) {
         rb_ary_push(rowVal, val);
@@ -316,7 +392,7 @@ 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;
+  int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1, cast = 1;
 
   GetMysql2Result(self, wrapper);
 
@@ -343,6 +419,10 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     cacheRows = 0;
   }
 
+  if (rb_hash_aref(opts, sym_cast) == Qfalse) {
+    cast = 0;
+  }
+
   dbTz = rb_hash_aref(opts, sym_database_timezone);
   if (dbTz == sym_local) {
     db_timezone = intern_local;
@@ -387,7 +467,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
       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);
+        row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast);
         if (cacheRows) {
           rb_ary_store(wrapper->rows, i, row);
         }
@@ -413,6 +493,14 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   return wrapper->rows;
 }
 
+static VALUE rb_mysql_result_count(VALUE self) {
+  mysql2_result_wrapper *wrapper;
+
+  GetMysql2Result(self, wrapper);
+
+  return INT2FIX(mysql_num_rows(wrapper->result));
+}
+
 /* Mysql2::Result */
 VALUE rb_mysql_result_to_obj(MYSQL_RES * r) {
   VALUE obj;
@@ -438,6 +526,8 @@ void init_mysql2_result() {
   cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
   rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
   rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0);
+  rb_define_method(cMysql2Result, "count", rb_mysql_result_count, 0);
+  rb_define_alias(cMysql2Result, "size", "count");
 
   intern_encoding_from_charset = rb_intern("encoding_from_charset");
   intern_encoding_from_charset_code = rb_intern("encoding_from_charset_code");
@@ -460,6 +550,7 @@ void init_mysql2_result() {
   sym_database_timezone     = ID2SYM(rb_intern("database_timezone"));
   sym_application_timezone  = ID2SYM(rb_intern("application_timezone"));
   sym_cache_rows     = ID2SYM(rb_intern("cache_rows"));
+  sym_cast           = ID2SYM(rb_intern("cast"));
 
   opt_decimal_zero = rb_str_new2("0.0");
   rb_global_variable(&opt_decimal_zero); //never GC

data/ext/mysql2/result.h

@@ -8,10 +8,10 @@ typedef struct {
   VALUE fields;
   VALUE rows;
   VALUE encoding;
-  long numberOfFields;
+  unsigned int numberOfFields;
   unsigned long numberOfRows;
   unsigned long lastRowProcessed;
-  short int resultFreed;
+  char resultFreed;
   MYSQL_RES *result;
 } mysql2_result_wrapper;
 

data/ext/mysql2/wait_for_single_fd.h

@@ -0,0 +1,36 @@
+/*
+ * backwards compatibility for pre-1.9.3 C API
+ *
+ * Ruby 1.9.3 provides this API which allows the use of ppoll() on Linux
+ * to minimize select() and malloc() overhead on high-numbered FDs.
+ */
+#ifdef HAVE_RB_WAIT_FOR_SINGLE_FD
+#  include <ruby/io.h>
+#else
+#  define RB_WAITFD_IN  0x001
+#  define RB_WAITFD_PRI 0x002
+#  define RB_WAITFD_OUT 0x004
+
+static int my_wait_for_single_fd(int fd, int events, struct timeval *tvp)
+{
+  fd_set fdset;
+  fd_set *rfds = NULL;
+  fd_set *wfds = NULL;
+  fd_set *efds = NULL;
+
+  FD_ZERO(&fdset);
+  FD_SET(fd, &fdset);
+
+  if (events & RB_WAITFD_IN)
+    rfds = &fdset;
+  if (events & RB_WAITFD_OUT)
+    wfds = &fdset;
+  if (events & RB_WAITFD_PRI)
+    efds = &fdset;
+
+  return rb_thread_select(fd + 1, rfds, wfds, efds, tvp);
+}
+
+#define rb_wait_for_single_fd(fd,events,tvp) \
+        my_wait_for_single_fd((fd),(events),(tvp))
+#endif

data/lib/active_record/connection_adapters/em_mysql2_adapter.rb

@@ -15,8 +15,8 @@ module ActiveRecord
 end
 
 require 'fiber'
-require 'eventmachine' unless defined? EventMachine
-require 'mysql2' unless defined? Mysql2
+require 'eventmachine'
+require 'mysql2'
 require 'active_record/connection_adapters/mysql2_adapter'
 require 'active_record/fiber_patches'
 
@@ -35,25 +35,26 @@ module Mysql2
             results = @client.async_result
             @deferable.succeed(results)
           rescue Exception => e
-            puts e.backtrace.join("\n\t")
             @deferable.fail(e)
           end
         end
       end
 
       def query(sql, opts={})
-        if EM.reactor_running?
+        if ::EM.reactor_running?
           super(sql, opts.merge(:async => true))
-          deferable = ::EM::DefaultDeferrable.new
-          ::EM.watch(self.socket, Watcher, self, deferable).notify_readable = true
+          deferrable = ::EM::DefaultDeferrable.new
+          ::EM.watch(self.socket, Watcher, self, deferrable).notify_readable = true
           fiber = Fiber.current
-          deferable.callback do |result|
+          deferrable.callback do |result|
             fiber.resume(result)
           end
-          deferable.errback do |err|
+          deferrable.errback do |err|
             fiber.resume(err)
           end
-          Fiber.yield
+          Fiber.yield.tap do |result|
+            raise result if result.is_a?(Exception)
+          end
         else
           super(sql, opts)
         end

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'mysql2' unless defined? Mysql2
+require 'mysql2'
 
 module ActiveRecord
   class Base
@@ -18,6 +18,9 @@ module ActiveRecord
   end
 
   module ConnectionAdapters
+    class Mysql2IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths) #:nodoc:
+    end
+
     class Mysql2Column < Column
       BOOL = "tinyint(1)"
       def extract_default(default)
@@ -35,59 +38,10 @@ module ActiveRecord
       end
 
       def has_default?
-        return false if sql_type =~ /blob/i || type == :text #mysql forbids defaults on blob and text columns
+        return false if sql_type =~ /blob/i || type == :text # mysql forbids defaults on blob and text columns
         super
       end
 
-      # Returns the Ruby class that corresponds to the abstract data type.
-      def klass
-        case type
-          when :integer       then Fixnum
-          when :float         then Float
-          when :decimal       then BigDecimal
-          when :datetime      then Time
-          when :date          then Date
-          when :timestamp     then Time
-          when :time          then Time
-          when :text, :string then String
-          when :binary        then String
-          when :boolean       then Object
-        end
-      end
-
-      def type_cast(value)
-        return nil if value.nil?
-        case type
-          when :string                then value
-          when :text                  then value
-          when :integer               then value.to_i rescue value ? 1 : 0
-          when :float                 then value.to_f # returns self if it's already a Float
-          when :decimal               then self.class.value_to_decimal(value)
-          when :datetime, :timestamp  then value.class == Time ? value : self.class.string_to_time(value)
-          when :time                  then value.class == Time ? value : self.class.string_to_dummy_time(value)
-          when :date                  then value.class == Date ? value : self.class.string_to_date(value)
-          when :binary                then value
-          when :boolean               then self.class.value_to_boolean(value)
-          else value
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-          when :string                then nil
-          when :text                  then nil
-          when :integer               then "#{var_name}.to_i rescue #{var_name} ? 1 : 0"
-          when :float                 then "#{var_name}.to_f"
-          when :decimal               then "#{self.class.name}.value_to_decimal(#{var_name})"
-          when :datetime, :timestamp  then "#{var_name}.class == Time ? #{var_name} : #{self.class.name}.string_to_time(#{var_name})"
-          when :time                  then "#{var_name}.class == Time ? #{var_name} : #{self.class.name}.string_to_dummy_time(#{var_name})"
-          when :date                  then "#{var_name}.class == Date ? #{var_name} : #{self.class.name}.string_to_date(#{var_name})"
-          when :binary                then nil
-          when :boolean               then "#{self.class.name}.value_to_boolean(#{var_name})"
-          else nil
-        end
-      end
-
       private
         def simplified_type(field_type)
           return :boolean if Mysql2Adapter.emulate_booleans && field_type.downcase.index(BOOL)
@@ -203,7 +157,7 @@ module ActiveRecord
       end
 
       def quote_column_name(name) #:nodoc:
-        @quoted_column_names[name] ||= "`#{name}`"
+        @quoted_column_names[name] ||= "`#{name.to_s.gsub('`', '``')}`"
       end
 
       def quote_table_name(name) #:nodoc:
@@ -239,10 +193,7 @@ module ActiveRecord
 
       def active?
         return false unless @connection
-        @connection.query 'select 1'
-        true
-      rescue Mysql2::Error
-        false
+        @connection.ping
       end
 
       def reconnect!
@@ -447,7 +398,7 @@ module ActiveRecord
           if current_index != row[:Key_name]
             next if row[:Key_name] == PRIMARY # skip the primary key
             current_index = row[:Key_name]
-            indexes << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique] == 0, [], [])
+            indexes << Mysql2IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique] == 0, [], [])
           end
 
           indexes.last.columns << row[:Column_name]
@@ -623,7 +574,7 @@ module ActiveRecord
 
           # increase timeout so mysql server doesn't disconnect us
           wait_timeout = @config[:wait_timeout]
-          wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+          wait_timeout = 2147483 unless wait_timeout.is_a?(Fixnum)
           variable_assignments << "@@wait_timeout = #{wait_timeout}"
 
           execute("SET #{variable_assignments.join(', ')}", :skip_logging)