mysql2 0.3.5 → 0.3.6

data/.rspec

@@ -1,2 +1,3 @@
 --format documentation
 --colour
+--fail-fast

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.3.6 (June 17th, 2011)
+* fix bug in Time/DateTime range detection
+* (win32) fix bug where the Mysql2::Client object wasn't cleaned up properly if interrupted during a query
+* add Mysql2::Result#count (aliased as size) to get the row count for the dataset
+  this can be especially helpful if you want to get the number of rows without having to inflate
+  the entire dataset into ruby (since this happens lazily)
+
 ## 0.3.5 (June 15th, 2011)
 * bug fix for Time/DateTime usage depending on 32/64bit Ruby
 
@@ -26,6 +33,16 @@
 * BREAKING CHANGE: the ActiveRecord adapter has been pulled into Rails 3.1 and is no longer part of the gem
 * added Mysql2::Client.escape (class-level) for raw one-off non-encoding-aware escaping
 
+## 0.2.11 (June 17th, 2011)
+* fix bug in Time/DateTime range detection
+* (win32) fix bug where the Mysql2::Client object wasn't cleaned up properly if interrupted during a query
+* add Mysql2::Result#count (aliased as size) to get the row count for the dataset
+  this can be especially helpful if you want to get the number of rows without having to inflate
+  the entire dataset into ruby (since this happens lazily)
+
+## 0.2.10 (June 15th, 2011)
+* bug fix for Time/DateTime usage depending on 32/64bit Ruby
+
 ## 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

data/README.md

@@ -44,6 +44,8 @@ escaped = client.escape("gi'thu\"bbe\0r's")
 results = client.query("SELECT * FROM users WHERE group='#{escaped}'")
 ```
 
+You can get a count of your results with `results.count`.
+
 Finally, iterate over the results:
 
 ``` ruby

data/ext/mysql2/client.c

@@ -171,7 +171,7 @@ static VALUE allocate(VALUE klass) {
   return obj;
 }
 
-static VALUE rb_mysql_client_escape(VALUE klass, VALUE str) {
+static VALUE rb_mysql_client_escape(RB_MYSQL_UNUSED VALUE klass, VALUE str) {
   unsigned char *newStr;
   VALUE rb_str;
   unsigned long newLen, oldLen;
@@ -263,8 +263,17 @@ static VALUE nogvl_read_query_result(void *ptr) {
 
 /* 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);
+  mysql_client_wrapper *wrapper;
+  MYSQL_RES *result;
+
+  wrapper = (mysql_client_wrapper *)ptr;
+  result = mysql_store_result(wrapper->client);
+
+  // once our result is stored off, this connection is
+  // ready for another command to be issued
+  wrapper->active = 0;
+
+  return (VALUE)result;
 }
 
 static VALUE rb_mysql_client_async_result(VALUE self) {
@@ -286,10 +295,7 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
     return rb_raise_mysql2_error(wrapper);
   }
 
-  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper->client, RUBY_UBF_IO, 0);
-
-  // we have our result, mark this connection inactive
-  MARK_CONN_INACTIVE(self);
+  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
 
   if (result == NULL) {
     if (mysql_field_count(wrapper->client) != 0) {
@@ -329,7 +335,6 @@ static VALUE disconnect_and_raise(VALUE self, VALUE error) {
 
   return Qnil;
 }
-#endif
 
 static VALUE do_query(void *args) {
   struct async_query_args *async_args;
@@ -383,9 +388,33 @@ static VALUE do_query(void *args) {
 
   return Qnil;
 }
+#else
+static VALUE finish_and_mark_inactive(void *args) {
+  VALUE self;
+  MYSQL_RES *result;
+
+  self = (VALUE)args;
+
+  GET_CLIENT(self);
+
+  if (wrapper->active) {
+    // if we got here, the result hasn't been read off the wire yet
+    // so lets do that and then throw it away because we have no way
+    // of getting it back up to the caller from here
+    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+    mysql_free_result(result);
+
+    wrapper->active = 0;
+  }
+
+  return Qnil;
+}
+#endif
 
 static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
+#ifndef _WIN32
   struct async_query_args async_args;
+#endif
   struct nogvl_send_query_args args;
   int async = 0;
   VALUE opts, defaults;
@@ -443,7 +472,7 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   }
 #else
   // this will just block until the result is ready
-  return rb_mysql_client_async_result(self);
+  return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self);
 #endif
 }
 

data/ext/mysql2/result.c

@@ -1,30 +1,50 @@
 #include <mysql2_ext.h>
+#include <stdint.h>
 
 #ifdef HAVE_RUBY_ENCODING_H
 static rb_encoding *binaryEncoding;
 #endif
 
-#if SIZEOF_INT < SIZEOF_LONG
-/**
- * on 64bit platforms we can handle dates way outside 2038-01-19T03:14:07
- * because of how I'm performing the math below, this will allow a maximum
- * timestamp of 9846-12-12T11:5999:59
-*/
-#define MYSQL2_MAX_YEAR 9999
+#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
- * 2082 = 2038+1+19+3+14+7
+ * 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_YEAR 2082
+#define MYSQL2_MAX_TIME 64318634047ULL
 #endif
 
-#ifdef NEGATIVE_TIME_T
-/* 1901-12-13 20:45:52 UTC : The oldest time in 32-bit signed time_t. */
-#define MYSQL2_MIN_YEAR 1902
+#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:00 UTC : The Unix epoch - the oldest time in portable time_t. */
-#define MYSQL2_MIN_YEAR 1970
+/* 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;
@@ -244,16 +264,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 < MYSQL2_MIN_YEAR || year+month+day+hour+min+sec > MYSQL2_MAX_YEAR) { // 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);
@@ -464,6 +488,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;
@@ -489,6 +521,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");

data/lib/mysql2.rb

@@ -5,9 +5,9 @@ require 'rational' unless RUBY_VERSION >= '1.9.2'
 
 require 'mysql2/version' unless defined? Mysql2::VERSION
 require 'mysql2/error'
+require 'mysql2/result'
 require 'mysql2/mysql2'
 require 'mysql2/client'
-require 'mysql2/result'
 
 # = Mysql2
 #

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.3.5"
+  VERSION = "0.3.6"
 end

data/spec/mysql2/client_spec.rb

@@ -410,7 +410,7 @@ describe Mysql2::Client do
   context 'write operations api' do
     before(:each) do
       @client.query "USE test"
-      @client.query "CREATE TABLE lastIdTest (`id` int(11) NOT NULL AUTO_INCREMENT, blah INT(11), PRIMARY KEY (`id`))"
+      @client.query "CREATE TABLE IF NOT EXISTS lastIdTest (`id` int(11) NOT NULL AUTO_INCREMENT, blah INT(11), PRIMARY KEY (`id`))"
     end
 
     after(:each) do

data/spec/mysql2/result_spec.rb

@@ -28,6 +28,18 @@ describe Mysql2::Result do
     }.should_not raise_error(Mysql2::Error)
   end
 
+  it "should respond to #count, which is aliased as #size" do
+    r = @client.query "SELECT 1"
+    r.should respond_to :count
+    r.should respond_to :size
+  end
+
+  it "should be able to return the number of rows in the result set" do
+    r = @client.query "SELECT 1"
+    r.count.should eql(1)
+    r.size.should eql(1)
+  end
+
   context "metadata queries" do
     it "should show tables" do
       @result = @client.query "SHOW TABLES"
@@ -166,56 +178,69 @@ describe Mysql2::Result do
 
     it "should return Time for a DATETIME value when within the supported range" do
       @test_result['date_time_test'].class.should eql(Time)
-      @test_result['date_time_test'].strftime("%F %T").should eql('2010-04-04 11:44:00')
+      @test_result['date_time_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2010-04-04 11:44:00')
     end
 
-    it "should return DateTime for a DATETIME value when outside the supported range, Time if otherwise" do
-      if RUBY_PLATFORM =~ /mswin/
-        inside_year = 1970
-        outside_year = inside_year-1
+    if 1.size == 4 # 32bit
+      if RUBY_VERSION =~ /1.9/
+        klass = Time
       else
-        inside_year = 1902
-        outside_year = inside_year-1
-      end
-      r = @client.query("SELECT CAST('#{inside_year}-1-1 01:01:01' AS DATETIME) as test")
-      if defined?(RUBY_ENGINE) && RUBY_ENGINE =~ /rbx/
         klass = DateTime
-      else
-        klass = Time
       end
-      r.first['test'].class.should eql(klass)
 
-      r = @client.query("SELECT CAST('#{outside_year}-1-1 01:01:01' AS DATETIME) as test")
-      r.first['test'].class.should eql(DateTime)
-    end
+      it "should return DateTime when timestamp is < 1901-12-13 20:45:52" do
+                                      # 1901-12-13T20:45:52 is the min for 32bit Ruby 1.8
+        r = @client.query("SELECT CAST('1901-12-13 20:45:51' AS DATETIME) as test")
+        r.first['test'].class.should eql(klass)
+      end
 
-    if 1.size == 4 # 32bit
       it "should return DateTime when timestamp is > 2038-01-19T03:14:07" do
                                       # 2038-01-19T03:14:07 is the max for 32bit Ruby 1.8
         r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
-        r.first['test'].class.should eql(DateTime)
+        r.first['test'].class.should eql(klass)
       end
     elsif 1.size == 8 # 64bit
-      it "should return Time when timestamp is > 2038-01-19T03:14:07" do
-                                      # 2038-01-19 03:14:07 is the max for 32bit Ruby 1.8
-        r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
-        r.first['test'].class.should eql(Time)
+      if RUBY_VERSION =~ /1.9/
+        it "should return Time when timestamp is < 1901-12-13 20:45:52" do
+          r = @client.query("SELECT CAST('1901-12-13 20:45:51' AS DATETIME) as test")
+          r.first['test'].class.should eql(Time)
+        end
+
+        it "should return Time when timestamp is > 2038-01-19T03:14:07" do
+          r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
+          r.first['test'].class.should eql(Time)
+        end
+      else
+        it "should return Time when timestamp is > 0138-12-31 11:59:59" do
+          r = @client.query("SELECT CAST('0139-1-1 00:00:00' AS DATETIME) as test")
+          r.first['test'].class.should eql(Time)
+        end
+
+        it "should return DateTime when timestamp is < 0139-1-1T00:00:00" do
+          r = @client.query("SELECT CAST('0138-12-31 11:59:59' AS DATETIME) as test")
+          r.first['test'].class.should eql(DateTime)
+        end
+
+        it "should return Time when timestamp is > 2038-01-19T03:14:07" do
+          r = @client.query("SELECT CAST('2038-01-19 03:14:08' AS DATETIME) as test")
+          r.first['test'].class.should eql(Time)
+        end
       end
     end
 
     it "should return Time for a TIMESTAMP value when within the supported range" do
       @test_result['timestamp_test'].class.should eql(Time)
-      @test_result['timestamp_test'].strftime("%F %T").should eql('2010-04-04 11:44:00')
+      @test_result['timestamp_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2010-04-04 11:44:00')
     end
 
     it "should return Time for a TIME value" do
       @test_result['time_test'].class.should eql(Time)
-      @test_result['time_test'].strftime("%F %T").should eql('2000-01-01 11:44:00')
+      @test_result['time_test'].strftime("%Y-%m-%d %H:%M:%S").should eql('2000-01-01 11:44:00')
     end
 
     it "should return Date for a DATE value" do
       @test_result['date_test'].class.should eql(Date)
-      @test_result['date_test'].strftime("%F").should eql('2010-04-04')
+      @test_result['date_test'].strftime("%Y-%m-%d").should eql('2010-04-04')
     end
 
     it "should return String for an ENUM value" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mysql2
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 31
   prerelease: 
   segments: 
   - 0
   - 3
-  - 5
-  version: 0.3.5
+  - 6
+  version: 0.3.6
 platform: ruby
 authors: 
 - Brian Lopez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-16 00:00:00 -07:00
+date: 2011-06-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency