mysql2 0.2.3 → 0.2.5

data/.gitignore

@@ -9,3 +9,4 @@ mkmf.log
 pkg/
 tmp
 vendor
+lib/mysql2/mysql2.rb

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--colour

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.2.5 (October 19th, 2010)
+* fixes for easier Win32 binary gem deployment for targeting 1.8 and 1.9 in the same gem
+* refactor of connection checks and management to avoid race conditions with the GC/threading to prevent the unexpected loss of connections
+* update the default flags during connection
+* add support for setting wait_timeout on AR adapter
+* upgrade to rspec2
+* bugfix for an edge case where the GC would clean up a Mysql2::Client object before the underlying MYSQL pointer had been initialized
+* fix to CFLAGS to allow compilation on SPARC with sunstudio compiler - Anko painting <anko.com+github@gmail.com>
+
+## 0.2.4 (September 17th, 2010)
+* a few patches for win32 support from Luis Lavena - thanks man!
+* bugfix from Eric Wong to avoid a potential stack overflow during Mysql2::Client#escape
+* added the ability to turn internal row caching on/off via the :cache_rows => true/false option
+* a couple of small patches for rbx compatibility
+* set IndexDefinition#length in AR adapter - Kouhei Yanagita <yanagi@shakenbu.org>
+* fix a long-standing data corruption bug - thank you thank you thank you to @joedamato (http://github.com/ice799)
+* bugfix from calling mysql_close on a closed/freed connection surfaced by the above fix
+
 ## 0.2.3 (August 20th, 2010)
 * connection flags can now be passed to the constructor via the :flags key
 * switch AR adapter connection over to use FOUND_ROWS option

data/README.rdoc

@@ -89,18 +89,18 @@ or
 
 === Array of Arrays
 
-Pass the {:as => :array} option to any of the above methods of configuration
+Pass the :as => :array option to any of the above methods of configuration
 
 === Array of Hashes
 
-The default result type is set to :hash, but you can override a previous setting to something else with {:as => :hash}
+The default result type is set to :hash, but you can override a previous setting to something else with :as => :hash
 
 === Others...
 
-I may add support for {:as => :csv} or even {:as => :json} to allow for *much* more efficient generation of those data types from result sets.
+I may add support for :as => :csv or even :as => :json to allow for *much* more efficient generation of those data types from result sets.
 If you'd like to see either of these (or others), open an issue and start bugging me about it ;)
 
-== Timezones
+=== Timezones
 
 Mysql2 now supports two timezone options:
 
@@ -112,14 +112,14 @@ Then, if :application_timezone is set to say - :local - Mysql2 will then convert
 
 Both options only allow two values - :local or :utc - with the exception that :application_timezone can be [and defaults to] nil
 
-== Casting "boolean" columns
+=== Casting "boolean" columns
 
 You can now tell Mysql2 to cast tinyint(1) fields to boolean values in Ruby with the :cast_booleans option.
 
   client = Mysql2::Client.new
   result = client.query("SELECT * FROM table_with_boolean_field", :cast_booleans => true)
 
-== Async
+=== Async
 
 Mysql2::Client takes advantage of the MySQL C API's (undocumented) non-blocking function mysql_send_query for *all* queries.
 But, in order to take full advantage of it in your Ruby code, you can do:
@@ -136,6 +136,14 @@ NOTE: Because of the way MySQL's query API works, this method will block until t
 So if you really need things to stay async, it's best to just monitor the socket with something like EventMachine.
 If you need multiple query concurrency take a look at using a connection pool.
 
+=== Row Caching
+
+By default, Mysql2 will cache rows that have been created in Ruby (since this happens lazily).
+This is especially helpful since it saves the cost of creating the row in Ruby if you were to iterate over the collection again.
+
+If you only plan on using each row once, then it's much more efficient to disable this behavior by setting the :cache_rows option to false.
+This would be helpful if you wanted to iterate over the results in a streaming manner. Meaning the GC would cleanup rows you don't need anymore as you're iterating over the result set.
+
 == ActiveRecord
 
 To use the ActiveRecord driver, all you should need to do is have this gem installed and set the adapter in your database.yml to "mysql2".
@@ -182,6 +190,8 @@ For example, if you were to yield 4 rows from a 100 row dataset, only 4 hashes w
 Now say you were to iterate over that same collection again, this time yielding 15 rows - the 4 previous rows that had already been turned into ruby hashes would be pulled from an internal cache, then 11 more would be created and stored in that cache.
 Once the entire dataset has been converted into ruby objects, Mysql2::Result will free the Mysql C result object as it's no longer needed.
 
+This caching behavior can be disabled by setting the :cache_rows option to false.
+
 As for field values themselves, I'm workin on it - but expect that soon.
 
 == Compatibility
@@ -224,7 +234,7 @@ then iterating over every row using an #each like method yielding a block:
 
 == Special Thanks
 
-* Eric Wong - for the contribution (and informative explanations of) of some thread-safety, non-blocking I/O and cleanup patches. You rock dude
+* Eric Wong - for the contribution (and the informative explanations) of some thread-safety, non-blocking I/O and cleanup patches. You rock dude
 * Yury Korolev (http://github.com/yury) - for TONS of help testing the ActiveRecord adapter
 * Aaron Patterson (http://github.com/tenderlove) - tons of contributions, suggestions and general badassness
 * Mike Perham (http://github.com/mperham) - Async ActiveRecord adapter (uses Fibers and EventMachine)

data/Rakefile

@@ -1,42 +1,5 @@
 # encoding: UTF-8
-begin
-  require 'jeweler'
-  JEWELER = Jeweler::Tasks.new do |gem|
-    gem.name = "mysql2"
-    gem.summary = "A simple, fast Mysql library for Ruby, binding to libmysql"
-    gem.email = "seniorlopez@gmail.com"
-    gem.homepage = "http://github.com/brianmario/mysql2"
-    gem.authors = ["Brian Lopez"]
-    gem.require_paths = ["lib", "ext"]
-    gem.extra_rdoc_files = `git ls-files *.rdoc`.split("\n")
-    gem.files = `git ls-files`.split("\n")
-    gem.extensions = ["ext/mysql2/extconf.rb"]
-    gem.files.include %w(lib/jeweler/templates/.document lib/jeweler/templates/.gitignore)
-    # gem.rubyforge_project = "mysql2"
-  end
-rescue LoadError
-  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler -s http://gems.github.com"
-end
-
 require 'rake'
-require 'spec/rake/spectask'
-
-desc "Run all examples with RCov"
-Spec::Rake::SpecTask.new('spec:rcov') do |t|
-  t.spec_files = FileList['spec/']
-  t.rcov = true
-  t.rcov_opts = lambda do
-    IO.readlines("spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
-  end
-end
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_files = FileList['spec/']
-  t.spec_opts << '--options' << 'spec/spec.opts'
-  t.verbose = true
-  t.warning = true
-end
-
-task :default => :spec
 
 # Load custom tasks
 Dir['tasks/*.rake'].sort.each { |f| load f }

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.2.5

data/benchmark/query_with_mysql_casting.rb

@@ -70,7 +70,7 @@ Benchmark.bmbm do |x|
   end
 
   do_mysql = DataObjects::Connection.new("mysql://localhost/#{database}")
-  command = DataObjects::Mysql::Command.new do_mysql, sql
+  command = do_mysql.create_command sql
   x.report do
     puts "do_mysql"
     number_of.times do

data/ext/mysql2/client.c

@@ -8,20 +8,18 @@ static VALUE intern_encoding_from_charset;
 static ID sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array;
 static ID intern_merge, intern_error_number_eql, intern_sql_state_eql;
 
-#define REQUIRE_OPEN_DB(_ctxt) \
-  if(!_ctxt->net.vio) { \
+#define REQUIRE_OPEN_DB(wrapper) \
+  if(wrapper->closed) { \
     rb_raise(cMysql2Error, "closed MySQL connection"); \
     return Qnil; \
   }
 
 #define MARK_CONN_INACTIVE(conn) \
-  wrapper->active = 0;
+  wrapper->active = 0
 
 #define GET_CLIENT(self) \
   mysql_client_wrapper *wrapper; \
-  MYSQL *client; \
-  Data_Get_Struct(self, mysql_client_wrapper, wrapper); \
-  client = &wrapper->client;
+  Data_Get_Struct(self, mysql_client_wrapper, wrapper)
 
 /*
  * used to pass all arguments to mysql_real_connect while inside
@@ -85,11 +83,10 @@ static VALUE rb_raise_mysql2_error(MYSQL *client) {
 }
 
 static VALUE nogvl_init(void *ptr) {
-  MYSQL * client = (MYSQL *)ptr;
+  MYSQL *client;
 
   /* may initialize embedded server and read /etc/services off disk */
-  client = mysql_init(NULL);
-
+  client = mysql_init((MYSQL *)ptr);
   return client ? Qtrue : Qfalse;
 }
 
@@ -107,38 +104,42 @@ static VALUE nogvl_connect(void *ptr) {
   return client ? Qtrue : Qfalse;
 }
 
-static void rb_mysql_client_free(void * ptr) {
-  mysql_client_wrapper * wrapper = (mysql_client_wrapper *)ptr;
-  MYSQL * client = &wrapper->client;
-
-  /*
-   * 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
-   * anyways, so ensure the socket write does not block our interpreter
-   */
-  int fd = client->net.fd;
-  int flags;
-
-  if (fd >= 0) {
+static VALUE nogvl_close(void *ptr) {
+  mysql_client_wrapper *wrapper = ptr;
+  if (!wrapper->closed) {
+    wrapper->closed = 1;
+
     /*
+     * 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
+     * anyways, so ensure the socket write does not block our interpreter
+     *
+     *
      * if the socket is dead we have no chance of blocking,
      * so ignore any potential fcntl errors since they don't matter
      */
-    flags = fcntl(fd, F_GETFL);
+#ifndef _WIN32
+    int flags = fcntl(wrapper->client->net.fd, F_GETFL);
     if (flags > 0 && !(flags & O_NONBLOCK))
-      fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+      fcntl(wrapper->client->net.fd, F_SETFL, flags | O_NONBLOCK);
+#else
+    u_long iMode = 1;
+    ioctlsocket(wrapper->client->net.fd, FIONBIO, &iMode);
+#endif
+
+    mysql_close(wrapper->client);
+    free(wrapper->client);
   }
 
-  /* It's safe to call mysql_close() on an already closed connection. */
-  mysql_close(client);
-  xfree(ptr);
+  return Qnil;
 }
 
-static VALUE nogvl_close(void * ptr) {
-  MYSQL *client = (MYSQL *)ptr;
-  mysql_close(client);
-  client->net.fd = -1;
-  return Qnil;
+static void rb_mysql_client_free(void * ptr) {
+  mysql_client_wrapper *wrapper = (mysql_client_wrapper *)ptr;
+
+  nogvl_close(wrapper);
+
+  xfree(ptr);
 }
 
 static VALUE allocate(VALUE klass) {
@@ -147,12 +148,14 @@ 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->closed = 1;
+  wrapper->client = (MYSQL*)malloc(sizeof(MYSQL));
   return obj;
 }
 
 static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE port, VALUE database, VALUE socket, VALUE flags) {
   struct nogvl_connect_args args;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
   args.host = NIL_P(host) ? "localhost" : StringValuePtr(host);
   args.unix_socket = NIL_P(socket) ? NULL : StringValuePtr(socket);
@@ -160,12 +163,12 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
   args.user = NIL_P(user) ? NULL : StringValuePtr(user);
   args.passwd = NIL_P(pass) ? NULL : StringValuePtr(pass);
   args.db = NIL_P(database) ? NULL : StringValuePtr(database);
-  args.mysql = client;
-  args.client_flag = NUM2INT(flags);
+  args.mysql = wrapper->client;
+  args.client_flag = NUM2ULONG(flags);
 
   if (rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0) == Qfalse) {
     // unable to connect
-    return rb_raise_mysql2_error(client);
+    return rb_raise_mysql2_error(wrapper->client);
   }
 
   return self;
@@ -178,9 +181,11 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
  * for the garbage collector.
  */
 static VALUE rb_mysql_client_close(VALUE self) {
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
-  rb_thread_blocking_region(nogvl_close, client, RUBY_UBF_IO, 0);
+  if (!wrapper->closed) {
+    rb_thread_blocking_region(nogvl_close, wrapper, RUBY_UBF_IO, 0);
+  }
 
   return Qnil;
 }
@@ -221,30 +226,30 @@ static VALUE nogvl_store_result(void *ptr) {
 
 static VALUE rb_mysql_client_async_result(VALUE self) {
   MYSQL_RES * result;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(client);
-  if (rb_thread_blocking_region(nogvl_read_query_result, client, RUBY_UBF_IO, 0) == Qfalse) {
+  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
     MARK_CONN_INACTIVE(self);
-    return rb_raise_mysql2_error(client);
+    return rb_raise_mysql2_error(wrapper->client);
   }
 
-  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, client, RUBY_UBF_IO, 0);
+  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);
 
   if (result == NULL) {
-    if (mysql_field_count(client) != 0) {
-      rb_raise_mysql2_error(client);
+    if (mysql_field_count(wrapper->client) != 0) {
+      rb_raise_mysql2_error(wrapper->client);
     }
     return Qnil;
   }
 
   VALUE resultObj = rb_mysql_result_to_obj(result);
   // pass-through query options for result construction later
-  rb_iv_set(resultObj, "@query_options", rb_obj_dup(rb_iv_get(self, "@query_options")));
+  rb_iv_set(resultObj, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), rb_intern("dup"), 0));
 
 #ifdef HAVE_RUBY_ENCODING_H
   mysql2_result_wrapper * result_wrapper;
@@ -260,10 +265,10 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   int fd, retval;
   int async = 0;
   VALUE opts, defaults;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(client);
-  args.mysql = client;
+  REQUIRE_OPEN_DB(wrapper);
+  args.mysql = wrapper->client;
 
   // see if this connection is still waiting on a result from a previous query
   if (wrapper->active == 0) {
@@ -294,13 +299,13 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   if (rb_thread_blocking_region(nogvl_send_query, &args, RUBY_UBF_IO, 0) == Qfalse) {
     // an error occurred, we're not active anymore
     MARK_CONN_INACTIVE(self);
-    return rb_raise_mysql2_error(client);
+    return rb_raise_mysql2_error(wrapper->client);
   }
 
   if (!async) {
     // the below code is largely from do_mysql
     // http://github.com/datamapper/do
-    fd = client->net.fd;
+    fd = wrapper->client->net.fd;
     for(;;) {
       FD_ZERO(&fdset);
       FD_SET(fd, &fdset);
@@ -327,8 +332,9 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
 static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
   VALUE newStr;
   unsigned long newLen, oldLen;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
+  REQUIRE_OPEN_DB(wrapper);
   Check_Type(str, T_STRING);
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc = rb_default_internal_encoding();
@@ -338,15 +344,14 @@ static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
 #endif
 
   oldLen = RSTRING_LEN(str);
-  char escaped[(oldLen*2)+1];
+  newStr = rb_str_new(0, oldLen*2+1);
 
-  REQUIRE_OPEN_DB(client);
-  newLen = mysql_real_escape_string(client, escaped, StringValuePtr(str), oldLen);
+  newLen = mysql_real_escape_string(wrapper->client, RSTRING_PTR(newStr), StringValuePtr(str), oldLen);
   if (newLen == oldLen) {
     // no need to return a new ruby string if nothing changed
     return str;
   } else {
-    newStr = rb_str_new(escaped, newLen);
+    rb_str_resize(newStr, newLen);
 #ifdef HAVE_RUBY_ENCODING_H
     rb_enc_associate(newStr, conn_enc);
     if (default_internal_enc) {
@@ -360,6 +365,7 @@ static VALUE rb_mysql_client_escape(VALUE self, VALUE str) {
 static VALUE rb_mysql_client_info(VALUE self) {
   VALUE version = rb_hash_new(), client_info;
   GET_CLIENT(self);
+
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc = rb_default_internal_encoding();
   rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
@@ -379,17 +385,17 @@ static VALUE rb_mysql_client_info(VALUE self) {
 
 static VALUE rb_mysql_client_server_info(VALUE self) {
   VALUE version, server_info;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
+
+  REQUIRE_OPEN_DB(wrapper);
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc = rb_default_internal_encoding();
   rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
 #endif
 
-  REQUIRE_OPEN_DB(client);
-
   version = rb_hash_new();
-  rb_hash_aset(version, sym_id, LONG2FIX(mysql_get_server_version(client)));
-  server_info = rb_str_new2(mysql_get_server_info(client));
+  rb_hash_aset(version, sym_id, LONG2FIX(mysql_get_server_version(wrapper->client)));
+  server_info = rb_str_new2(mysql_get_server_info(wrapper->client));
 #ifdef HAVE_RUBY_ENCODING_H
   rb_enc_associate(server_info, conn_enc);
   if (default_internal_enc) {
@@ -401,34 +407,40 @@ static VALUE rb_mysql_client_server_info(VALUE self) {
 }
 
 static VALUE rb_mysql_client_socket(VALUE self) {
-  GET_CLIENT(self)
-  REQUIRE_OPEN_DB(client);
-  return INT2NUM(client->net.fd);
+  GET_CLIENT(self);
+  REQUIRE_OPEN_DB(wrapper);
+  return INT2NUM(wrapper->client->net.fd);
 }
 
 static VALUE rb_mysql_client_last_id(VALUE self) {
-  GET_CLIENT(self)
-  REQUIRE_OPEN_DB(client);
-  return ULL2NUM(mysql_insert_id(client));
+  GET_CLIENT(self);
+  REQUIRE_OPEN_DB(wrapper);
+  return ULL2NUM(mysql_insert_id(wrapper->client));
 }
 
 static VALUE rb_mysql_client_affected_rows(VALUE self) {
-  GET_CLIENT(self)
-  REQUIRE_OPEN_DB(client);
-  return ULL2NUM(mysql_affected_rows(client));
+  GET_CLIENT(self);
+  my_ulonglong retVal;
+
+  REQUIRE_OPEN_DB(wrapper);
+  retVal = mysql_affected_rows(wrapper->client);
+  if (retVal == (my_ulonglong)-1) {
+    rb_raise_mysql2_error(wrapper->client);
+  }
+  return ULL2NUM(retVal);
 }
 
 static VALUE set_reconnect(VALUE self, VALUE value) {
   my_bool reconnect;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
   if(!NIL_P(value)) {
     reconnect = value == Qfalse ? 0 : 1;
 
     /* set default reconnect behavior */
-    if (mysql_options(client, MYSQL_OPT_RECONNECT, &reconnect)) {
+    if (mysql_options(wrapper->client, MYSQL_OPT_RECONNECT, &reconnect)) {
       /* TODO: warning - unable to set reconnect behavior */
-      rb_warn("%s\n", mysql_error(client));
+      rb_warn("%s\n", mysql_error(wrapper->client));
     }
   }
   return value;
@@ -436,16 +448,16 @@ static VALUE set_reconnect(VALUE self, VALUE value) {
 
 static VALUE set_connect_timeout(VALUE self, VALUE value) {
   unsigned int connect_timeout = 0;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
   if(!NIL_P(value)) {
     connect_timeout = NUM2INT(value);
     if(0 == connect_timeout) return value;
 
     /* set default connection timeout behavior */
-    if (mysql_options(client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout)) {
+    if (mysql_options(wrapper->client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout)) {
       /* TODO: warning - unable to set connection timeout */
-      rb_warn("%s\n", mysql_error(client));
+      rb_warn("%s\n", mysql_error(wrapper->client));
     }
   }
   return value;
@@ -453,7 +465,7 @@ static VALUE set_connect_timeout(VALUE self, VALUE value) {
 
 static VALUE set_charset_name(VALUE self, VALUE value) {
   char * charset_name;
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
 #ifdef HAVE_RUBY_ENCODING_H
   VALUE new_encoding;
@@ -469,19 +481,19 @@ static VALUE set_charset_name(VALUE self, VALUE value) {
 
   charset_name = StringValuePtr(value);
 
-  if (mysql_options(client, MYSQL_SET_CHARSET_NAME, charset_name)) {
+  if (mysql_options(wrapper->client, MYSQL_SET_CHARSET_NAME, charset_name)) {
     /* TODO: warning - unable to set charset */
-    rb_warn("%s\n", mysql_error(client));
+    rb_warn("%s\n", mysql_error(wrapper->client));
   }
 
   return value;
 }
 
 static VALUE set_ssl_options(VALUE self, VALUE key, VALUE cert, VALUE ca, VALUE capath, VALUE cipher) {
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
   if(!NIL_P(ca) || !NIL_P(key)) {
-    mysql_ssl_set(client,
+    mysql_ssl_set(wrapper->client,
         NIL_P(key) ? NULL : StringValuePtr(key),
         NIL_P(cert) ? NULL : StringValuePtr(cert),
         NIL_P(ca) ? NULL : StringValuePtr(ca),
@@ -493,13 +505,14 @@ static VALUE set_ssl_options(VALUE self, VALUE key, VALUE cert, VALUE ca, VALUE
 }
 
 static VALUE init_connection(VALUE self) {
-  GET_CLIENT(self)
+  GET_CLIENT(self);
 
-  if (rb_thread_blocking_region(nogvl_init, client, RUBY_UBF_IO, 0) == Qfalse) {
+  if (rb_thread_blocking_region(nogvl_init, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
     /* TODO: warning - not enough memory? */
-    return rb_raise_mysql2_error(client);
+    return rb_raise_mysql2_error(wrapper->client);
   }
 
+  wrapper->closed = 0;
   return self;
 }
 

data/ext/mysql2/client.h

@@ -34,7 +34,8 @@ void init_mysql2_client();
 typedef struct {
   VALUE encoding;
   short int active;
-  MYSQL client;
+  short int closed;
+  MYSQL *client;
 } mysql_client_wrapper;
 
 #endif

data/ext/mysql2/extconf.rb

@@ -57,7 +57,7 @@ end
   asplode h unless have_header h
 end
 
-unless RUBY_PLATFORM =~ /mswin/
+unless RUBY_PLATFORM =~ /mswin/ or RUBY_PLATFORM =~ /sparc/
   $CFLAGS << ' -Wall -funroll-loops'
 end
 # $CFLAGS << ' -O0 -ggdb3 -Wextra'

data/ext/mysql2/result.c

@@ -12,7 +12,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 ID sym_symbolize_keys, sym_as, sym_array, sym_database_timezone, sym_application_timezone,
-          sym_local, sym_utc, sym_cast_booleans;
+          sym_local, sym_utc, sym_cast_booleans, sym_cache_rows;
 static ID intern_merge;
 
 static void rb_mysql_result_mark(void * wrapper) {
@@ -316,7 +316,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;
+  int symbolizeKeys = 0, asArray = 0, castBool = 0, cacheRows = 1;
 
   GetMysql2Result(self, wrapper);
 
@@ -339,6 +339,10 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     castBool = 1;
   }
 
+  if (rb_hash_aref(opts, sym_cache_rows) == Qfalse) {
+    cacheRows = 0;
+  }
+
   dbTz = rb_hash_aref(opts, sym_database_timezone);
   if (dbTz == sym_local) {
     db_timezone = intern_local;
@@ -369,7 +373,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
   }
 
-  if (wrapper->lastRowProcessed == 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++) {
@@ -380,11 +384,13 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     rowsProcessed = RARRAY_LEN(wrapper->rows);
     for (i = 0; i < wrapper->numberOfRows; i++) {
       VALUE row;
-      if (i < rowsProcessed) {
+      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);
-        rb_ary_store(wrapper->rows, i, row);
+        if (cacheRows) {
+          rb_ary_store(wrapper->rows, i, row);
+        }
         wrapper->lastRowProcessed++;
       }
 
@@ -453,11 +459,12 @@ void init_mysql2_result() {
   sym_cast_booleans   = ID2SYM(rb_intern("cast_booleans"));
   sym_database_timezone     = ID2SYM(rb_intern("database_timezone"));
   sym_application_timezone  = ID2SYM(rb_intern("application_timezone"));
+  sym_cache_rows     = ID2SYM(rb_intern("cache_rows"));
 
-  rb_global_variable(&opt_decimal_zero); //never GC
   opt_decimal_zero = rb_str_new2("0.0");
-  rb_global_variable(&opt_float_zero);
+  rb_global_variable(&opt_decimal_zero); //never GC
   opt_float_zero = rb_float_new((double)0);
+  rb_global_variable(&opt_float_zero);
   opt_time_year = INT2NUM(2000);
   opt_time_month = INT2NUM(1);
   opt_utc_offset = INT2NUM(0);

data/ext/mysql2/result.h

@@ -8,7 +8,7 @@ typedef struct {
   VALUE fields;
   VALUE rows;
   VALUE encoding;
-  unsigned int numberOfFields;
+  long numberOfFields;
   unsigned long numberOfRows;
   unsigned long lastRowProcessed;
   short int resultFreed;

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -447,10 +447,11 @@ 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 << IndexDefinition.new(row[:Table], row[:Key_name], row[:Non_unique] == 0, [], [])
           end
 
           indexes.last.columns << row[:Column_name]
+          indexes.last.lengths << row[:Sub_part]
         end
         indexes
       end
@@ -616,8 +617,15 @@ module ActiveRecord
           # Turn this off. http://dev.rubyonrails.org/ticket/6778
           variable_assignments = ['SQL_AUTO_IS_NULL=0']
           encoding = @config[:encoding]
+
+          # make sure we set the encoding
           variable_assignments << "NAMES '#{encoding}'" if encoding
 
+          # increase timeout so mysql server doesn't disconnect us
+          wait_timeout = @config[:wait_timeout]
+          wait_timeout = 2592000 unless wait_timeout.is_a?(Fixnum)
+          variable_assignments << "@@wait_timeout = #{wait_timeout}"
+
           execute("SET #{variable_assignments.join(', ')}", :skip_logging)
         end
 

data/lib/mysql2/client.rb

@@ -2,12 +2,14 @@ module Mysql2
   class Client
     attr_reader :query_options
     @@default_query_options = {
-      :as => :hash,
-      :async => false,
-      :cast_booleans => false,
-      :symbolize_keys => false,
-      :database_timezone => :local, # timezone Mysql2 will assume datetime objects are stored in
-      :application_timezone => nil  # timezone Mysql2 will convert to before handing the object back to the caller
+      :as => :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
+      :async => false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
+      :cast_booleans => false,        # cast tinyint(1) fields as true/false in ruby
+      :symbolize_keys => false,       # return field names as symbols instead of strings
+      :database_timezone => :local,   # timezone Mysql2 will assume datetime objects are stored in
+      :application_timezone => nil,   # timezone Mysql2 will convert to before handing the object back to the caller
+      :cache_rows => true,            # tells Mysql2 to use it's internal row cache for results
+      :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION
     }
 
     def initialize(opts = {})
@@ -30,7 +32,7 @@ module Mysql2
       port     = opts[:port] || 3306
       database = opts[:database]
       socket   = opts[:socket]
-      flags    = opts[:flags] || 0
+      flags    = opts[:flags] ? opts[:flags] | @query_options[:connect_flags] : @query_options[:connect_flags]
 
       connect user, pass, host, port, database, socket, flags
     end

data/lib/mysql2/em.rb

@@ -13,12 +13,12 @@ module Mysql2
         end
 
         def notify_readable
+          detach
           begin
             @deferable.succeed(@client.async_result)
           rescue Exception => e
             @deferable.fail(e)
           end
-          detach
         end
       end
 

data/lib/mysql2/error.rb

@@ -7,5 +7,9 @@ module Mysql2
       @error_number = nil
       @sql_state    = nil
     end
+
+    # Mysql gem compatibility
+    alias_method :errno, :error_number
+    alias_method :error, :message
   end
 end

data/lib/mysql2.rb

@@ -12,5 +12,5 @@ require 'mysql2/result'
 #
 # A modern, simple and very fast Mysql library for Ruby - binding to libmysql
 module Mysql2
-  VERSION = "0.2.3"
+  VERSION = "0.2.5"
 end

data/mysql2.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mysql2}
-  s.version = "0.2.3"
+  s.version = "0.2.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Lopez"]
-  s.date = %q{2010-08-20}
+  s.date = %q{2010-10-19}
   s.email = %q{seniorlopez@gmail.com}
   s.extensions = ["ext/mysql2/extconf.rb"]
   s.extra_rdoc_files = [
@@ -17,6 +17,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     ".rspec",
      "CHANGELOG.md",
      "MIT-LICENSE",
      "README.rdoc",
@@ -29,7 +30,6 @@ Gem::Specification.new do |s|
      "benchmark/query_without_mysql_casting.rb",
      "benchmark/sequel.rb",
      "benchmark/setup_db.rb",
-     "benchmark/thread_alone.rb",
      "examples/eventmachine.rb",
      "examples/threaded.rb",
      "ext/mysql2/client.c",
@@ -54,10 +54,11 @@ Gem::Specification.new do |s|
      "spec/mysql2/error_spec.rb",
      "spec/mysql2/result_spec.rb",
      "spec/rcov.opts",
-     "spec/spec.opts",
      "spec/spec_helper.rb",
      "tasks/benchmarks.rake",
      "tasks/compile.rake",
+     "tasks/jeweler.rake",
+     "tasks/rspec.rake",
      "tasks/vendor_mysql.rake"
   ]
   s.homepage = %q{http://github.com/brianmario/mysql2}

data/spec/em/em_spec.rb

@@ -1,26 +1,49 @@
 # encoding: UTF-8
-require 'spec_helper'
-require 'mysql2/em'
+if defined? EventMachine
+  require 'spec_helper'
+  require 'mysql2/em'
 
-describe Mysql2::EM::Client do
-  it "should support async queries" do
-    results = []
-    EM.run do
-      client1 = Mysql2::EM::Client.new
-      defer1 = client1.query "SELECT sleep(0.05) as first_query"
-      defer1.callback do |result|
-        results << result.first
-        EM.stop_event_loop
+  describe Mysql2::EM::Client do
+    it "should support async queries" do
+      results = []
+      EM.run do
+        client1 = Mysql2::EM::Client.new
+        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
+        defer2 = client2.query "SELECT sleep(0.025) second_query"
+        defer2.callback do |result|
+          results << result.first
+        end
       end
 
-      client2 = Mysql2::EM::Client.new
-      defer2 = client2.query "SELECT sleep(0.025) second_query"
-      defer2.callback do |result|
-        results << result.first
+      results[0].keys.should include("second_query")
+      results[1].keys.should include("first_query")
+    end
+
+    it "should support queries in callbacks" do
+      results = []
+      EM.run do
+        client = Mysql2::EM::Client.new
+        defer1 = client.query "SELECT sleep(0.025) as first_query"
+        defer1.callback do |result|
+          results << result.first
+          defer2 = client.query "SELECT sleep(0.025) as second_query"
+          defer2.callback do |result|
+            results << result.first
+            EM.stop_event_loop
+          end
+        end
       end
+
+      results[0].keys.should include("first_query")
+      results[1].keys.should include("second_query")
     end
-    
-    results[0].keys.should include("second_query")
-    results[1].keys.should include("first_query")
   end
-end
+else
+  puts "EventMachine not installed, skipping the specs that use it"
+end

data/spec/mysql2/client_spec.rb

@@ -23,10 +23,10 @@ describe Mysql2::Client do
       end
     end
     client = klient.new :flags => Mysql2::Client::FOUND_ROWS
-    client.connect_args.last.last.should == Mysql2::Client::FOUND_ROWS
+    (client.connect_args.last.last & Mysql2::Client::FOUND_ROWS).should be_true
   end
 
-  it "should default flags to 0" do
+  it "should default flags to (REMEMBER_OPTIONS, LONG_PASSWORD, LONG_FLAG, TRANSACTIONS, PROTOCOL_41, SECURE_CONNECTION)" do
     klient = Class.new(Mysql2::Client) do
       attr_reader :connect_args
       def connect *args
@@ -35,7 +35,12 @@ describe Mysql2::Client do
       end
     end
     client = klient.new
-    client.connect_args.last.last.should == 0
+    (client.connect_args.last.last & (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
   end
 
   it "should have a global default_query_options hash" do
@@ -71,6 +76,9 @@ describe Mysql2::Client do
 
   it "should be able to close properly" do
     @client.close.should be_nil
+    lambda {
+      @client.query "SELECT 1"
+    }.should raise_error(Mysql2::Error)
   end
 
   it "should respond to #query" do
@@ -103,45 +111,75 @@ describe Mysql2::Client do
       }.should raise_error(Mysql2::Error)
     end
 
+    it "should require an open connection" do
+      @client.close
+      lambda {
+        @client.query "SELECT 1"
+      }.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 }
-      begin
-        mark[:START] = Time.now
-        pid = fork do
-          sleep 1 # wait for client "SELECT sleep(2)" query to start
-          Process.kill(:USR1, Process.ppid)
-          sleep # wait for explicit kill to prevent GC disconnect
+    if RUBY_PLATFORM !~ /mingw|mswin/
+      it "should run signal handlers while waiting for a response" do
+        mark = {}
+        trap(:USR1) { mark[:USR1] = Time.now }
+        begin
+          mark[:START] = Time.now
+          pid = fork do
+            sleep 1 # wait for client "SELECT sleep(2)" query to start
+            Process.kill(:USR1, Process.ppid)
+            sleep # wait for explicit kill to prevent GC disconnect
+          end
+          @client.query("SELECT sleep(2)")
+          mark[:END] = Time.now
+          mark.include?(:USR1).should be_true
+          (mark[:USR1] - mark[:START]).should >= 1
+          (mark[:USR1] - mark[:START]).should < 1.1
+          (mark[:END] - mark[:USR1]).should > 0.9
+          (mark[:END] - mark[:START]).should >= 2
+          (mark[:END] - mark[:START]).should < 2.1
+          Process.kill(:TERM, pid)
+          Process.waitpid2(pid)
+        ensure
+          trap(:USR1, 'DEFAULT')
         end
-        @client.query("SELECT sleep(2)")
-        mark[:END] = Time.now
-        mark.include?(:USR1).should be_true
-        (mark[:USR1] - mark[:START]).should >= 1
-        (mark[:USR1] - mark[:START]).should < 1.1
-        (mark[:END] - mark[:USR1]).should > 0.9
-        (mark[:END] - mark[:START]).should >= 2
-        (mark[:END] - mark[:START]).should < 2.1
-        Process.kill(:TERM, pid)
-        Process.waitpid2(pid)
-      ensure
-        trap(:USR1, 'DEFAULT')
       end
-    end if RUBY_PLATFORM !~ /mingw|mswin/
+    end
   end
 
   it "should respond to #escape" do
     @client.should respond_to(:escape)
   end
 
-  it "#escape should return a new SQL-escape version of the passed string" do
-    @client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
-  end
+  context "#escape" do
+    it "should return a new SQL-escape version of the passed string" do
+      @client.escape("abc'def\"ghi\0jkl%mno").should eql("abc\\'def\\\"ghi\\0jkl%mno")
+    end
+
+    it "should return the passed string if nothing was escaped" do
+      str = "plain"
+      @client.escape(str).object_id.should eql(str.object_id)
+    end
+
+    it "should not overflow the thread stack" do
+      lambda {
+        Thread.new { @client.escape("'" * 256 * 1024) }.join
+      }.should_not raise_error(SystemStackError)
+    end
 
-  it "#escape should return the passed string if nothing was escaped" do
-    str = "plain"
-    @client.escape(str).object_id.should eql(str.object_id)
+    it "should not overflow the process stack" do
+      lambda {
+        Thread.new { @client.escape("'" * 1024 * 1024 * 4) }.join
+      }.should_not raise_error(SystemStackError)
+    end
+
+    it "should require an open connection" do
+      @client.close
+      lambda {
+        @client.escape ""
+      }.should raise_error(Mysql2::Error)
+    end
   end
 
   it "should respond to #info" do
@@ -189,6 +227,13 @@ describe Mysql2::Client do
     server_info[:version].class.should eql(String)
   end
 
+  it "#server_info should require an open connection" do
+    @client.close
+    lambda {
+      @client.server_info
+    }.should raise_error(Mysql2::Error)
+  end
+
   if defined? Encoding
     context "strings returned by #server_info" do
       it "should default to the connection's encoding if Encoding.default_internal is nil" do
@@ -217,6 +262,13 @@ describe Mysql2::Client do
     @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 => "dfjhdi9wrhw", :username => 'asdfasdf8d2h'

data/spec/mysql2/error_spec.rb

@@ -13,4 +13,13 @@ describe Mysql2::Error do
   it "should respond to #sql_state" do
     @error.should respond_to(:sql_state)
   end
+
+  # Mysql gem compatibility
+  it "should alias #error_number to #errno" do
+    @error.should respond_to(:errno)
+  end
+
+  it "should alias #message to #error" do
+    @error.should respond_to(:error)
+  end
 end

data/spec/mysql2/result_spec.rb

@@ -47,8 +47,13 @@ describe Mysql2::Result do
       end
     end
 
-    it "should cache previously yielded results" do
-      @result.first.should eql(@result.first)
+    it "should cache previously yielded results by default" do
+      @result.first.object_id.should eql(@result.first.object_id)
+    end
+
+    it "should not cache previously yielded results if cache_rows is disabled" do
+      result = @client.query "SELECT 1", :cache_rows => false
+      result.first.object_id.should_not eql(result.first.object_id)
     end
   end
 

data/spec/spec_helper.rb

@@ -1,10 +1,11 @@
 # encoding: UTF-8
 
-require 'rubygems'
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require 'rspec'
 require 'mysql2'
 require 'timeout'
 
-Spec::Runner.configure do |config|
+RSpec.configure do |config|
   config.before(:all) do
     client = Mysql2::Client.new :database => 'test'
     client.query %[

data/tasks/compile.rake

@@ -1,19 +1,54 @@
 gem 'rake-compiler', '~> 0.7.1'
 require "rake/extensiontask"
 
-MYSQL_VERSION = "5.1.49"
-MYSQL_MIRROR  = ENV['MYSQL_MIRROR'] || "http://mysql.localhost.net.ar"
+MYSQL_VERSION = "5.1.51"
+MYSQL_MIRROR  = ENV['MYSQL_MIRROR'] || "http://mysql.he.net/"
 
-Rake::ExtensionTask.new("mysql2", JEWELER.gemspec) do |ext|
+def gemspec
+  @clean_gemspec ||= eval(File.read(File.expand_path('../../mysql2.gemspec', __FILE__)))
+end
+
+Rake::ExtensionTask.new("mysql2", gemspec) do |ext|
   # reference where the vendored MySQL got extracted
   mysql_lib = File.expand_path(File.join(File.dirname(__FILE__), '..', 'vendor', "mysql-#{MYSQL_VERSION}-win32"))
 
+  # DRY options feed into compile or cross-compile process
+  windows_options = [
+    "--with-mysql-include=#{mysql_lib}/include",
+    "--with-mysql-lib=#{mysql_lib}/lib/opt"
+  ]
+
   # automatically add build options to avoid need of manual input
   if RUBY_PLATFORM =~ /mswin|mingw/ then
-    ext.config_options << "--with-mysql-include=#{mysql_lib}/include"
-    ext.config_options << "--with-mysql-lib=#{mysql_lib}/lib/opt"
+    ext.config_options = windows_options
+  else
+    ext.cross_compile = true
+    ext.cross_platform = ['x86-mingw32', 'x86-mswin32-60']
+    ext.cross_config_options = windows_options
+
+    # inject 1.8/1.9 pure-ruby entry point when cross compiling only
+    ext.cross_compiling do |spec|
+      spec.files << 'lib/mysql2/mysql2.rb'
+    end
   end
 
   ext.lib_dir = File.join 'lib', 'mysql2'
+
+  # clean compiled extension
+  CLEAN.include "#{ext.lib_dir}/*.#{RbConfig::CONFIG['DLEXT']}"
 end
 Rake::Task[:spec].prerequisites << :compile
+
+file 'lib/mysql2/mysql2.rb' do |t|
+  name = gemspec.name
+  File.open(t.name, 'wb') do |f|
+    f.write <<-eoruby
+RUBY_VERSION =~ /(\\d+.\\d+)/
+require "#{name}/\#{$1}/#{name}"
+    eoruby
+  end
+end
+
+if Rake::Task.task_defined?(:cross)
+  Rake::Task[:cross].prerequisites << "lib/mysql2/mysql2.rb"
+end

data/tasks/jeweler.rake

@@ -0,0 +1,17 @@
+begin
+  require 'jeweler'
+  JEWELER = Jeweler::Tasks.new do |gem|
+    gem.name = "mysql2"
+    gem.summary = "A simple, fast Mysql library for Ruby, binding to libmysql"
+    gem.email = "seniorlopez@gmail.com"
+    gem.homepage = "http://github.com/brianmario/mysql2"
+    gem.authors = ["Brian Lopez"]
+    gem.require_paths = ["lib", "ext"]
+    gem.extra_rdoc_files = `git ls-files *.rdoc`.split("\n")
+    gem.files = `git ls-files`.split("\n")
+    gem.extensions = ["ext/mysql2/extconf.rb"]
+    gem.files.include %w(lib/jeweler/templates/.document lib/jeweler/templates/.gitignore)
+  end
+rescue LoadError
+  puts "jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
+end

data/tasks/rspec.rake

@@ -0,0 +1,16 @@
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+
+  desc "Run all examples with RCov"
+  RSpec::Core::RakeTask.new('spec:rcov') do |t|
+    t.rcov = true
+  end
+  RSpec::Core::RakeTask.new('spec') do |t|
+    t.verbose = true
+  end
+
+  task :default => :spec
+rescue LoadError
+  puts "rspec, or one of its dependencies, is not available. Install it with: sudo gem install rspec"
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mysql2
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 2
-  - 3
-  version: 0.2.3
+  - 5
+  version: 0.2.5
 platform: ruby
 authors: 
 - Brian Lopez
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-20 00:00:00 -07:00
+date: 2010-10-19 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,6 +29,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .gitignore
+- .rspec
 - CHANGELOG.md
 - MIT-LICENSE
 - README.rdoc
@@ -41,7 +42,6 @@ files:
 - benchmark/query_without_mysql_casting.rb
 - benchmark/sequel.rb
 - benchmark/setup_db.rb
-- benchmark/thread_alone.rb
 - examples/eventmachine.rb
 - examples/threaded.rb
 - ext/mysql2/client.c
@@ -66,10 +66,11 @@ files:
 - spec/mysql2/error_spec.rb
 - spec/mysql2/result_spec.rb
 - spec/rcov.opts
-- spec/spec.opts
 - spec/spec_helper.rb
 - tasks/benchmarks.rake
 - tasks/compile.rake
+- tasks/jeweler.rake
+- tasks/rspec.rake
 - tasks/vendor_mysql.rake
 has_rdoc: true
 homepage: http://github.com/brianmario/mysql2

data/benchmark/thread_alone.rb

@@ -1,20 +0,0 @@
-# encoding: UTF-8
-$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-
-require 'rubygems'
-require 'benchmark'
-require 'mysql2'
-
-iterations = 1000
-client = Mysql2::Client.new(:host => "localhost", :username => "root", :database => "test")
-query = lambda{ iterations.times{ client.query("SELECT mysql2_test.* FROM mysql2_test") } }
-Benchmark.bmbm do |x|
-  x.report('select') do
-    query.call
-  end
-  x.report('rb_thread_select') do
-    thread = Thread.new{ sleep(10) }
-    query.call
-    thread.kill
-  end
-end

data/spec/spec.opts

@@ -1,2 +0,0 @@
---format specdoc
---colour