changing gem name back to make it work with bundler

README

@@ -2,6 +2,8 @@
 
 An enhanced MySQL database driver. With support for async operations and threaded database access.
 
+Added Encoding awareness for Ruby 1.9.  Convert all data to default external encoding ( merged from http://github.com/lsegal/mysql-ruby )
+
 == Building
 
   gem build mysqlplus.gemspec
@@ -20,6 +22,18 @@ An enhanced MySQL database driver. With support for async operations and threade
       --with-mysql-dir=/usr/local/mysql \
       --with-mysql-lib=/usr/local/mysql/lib \
       --with-mysql-include=/usr/local/mysql/include
+== Using
+  to use within rails
+  add require 'mysqlplus' to the top of environment.rb
+  this instantiates the Mysql class that you can use.
+  and it will automagically use async_query instead of query, so it's a drop in replacement.
+
+  Same with other scripts that want to use it--just require 'mysqlplus' BEFORE you require 'mysql' and it will 
+  load the asynchronous version, then ignore the sequent require 'mysql' call.
+
+== Other helpful mysql utilities:
+  slim attributes http://slim-attributes.rubyforge.org/ boosts mysql speed by using arrays instead of hashed lookup.
+  Hash extension gem also results in speedups when used: http://blog.chak.org/2008/02/09/speeding-up-activerecord-with-hashes-take-2/
 
 === Credits
 
@@ -30,3 +44,6 @@ Lourens Naude for 1.9 integration help.
 
 === License
 Ruby License, http://www.ruby-lang.org/en/LICENSE.txt.
+
+== Mailing list
+http://groups.google.com/group/never-block?hl=en

TODO_LIST

@@ -0,0 +1,12 @@
+TODO list:
+
+Is there a quick, cheap, easy way to test for writability so we don't have to use select itself? Does select take any time that it's worth looking into this?
+
+Some of the tests currently might "think" they are using the ruby select but in reality be using the C select.
+
+gc_disabled is unused
+
+if they call get_result twice consecutively it should blow (and maybe already does).
+
+mingw support
+add slim attributes right in there :)

ext/extconf.rb

@@ -1,22 +1,75 @@
 require 'mkmf'
 
+def exec_command(command, flag_raise=false)
+  output = `#{command}`
+  return output.chomp if $? == 0
+  msg = "failed: #{command}"
+  raise msg if flag_raise
+  die msg
+end
+
+def die(message)
+  $stderr.puts "*** ERROR: #{message}"
+  exit 1
+end
+
 if /mswin32/ =~ RUBY_PLATFORM
   inc, lib = dir_config('mysql')
-  exit 1 unless have_library("libmysql")
+  #exit 1 unless have_library("libmysql")
+  have_library("libmysql")  or die "can't find libmysql."
 elsif mc = with_config('mysql-config') then
   mc = 'mysql_config' if mc == true
-  cflags = `#{mc} --cflags`.chomp
+  #cflags = `#{mc} --cflags`.chomp
-  exit 1 if $? != 0
+  #exit 1 if $? != 0
-  libs = `#{mc} --libs`.chomp
+  cflags = exec_command("#{mc} --cflags")
-  exit 1 if $? != 0
+  #libs = `#{mc} --libs`.chomp
+  #exit 1 if $? != 0
+  libs = exec_command("#{mc} --libs")
   $CPPFLAGS += ' ' + cflags
   $libs = libs + " " + $libs
 else
-  inc, lib = dir_config('mysql', '/usr/local')
+  puts "Trying to detect MySQL configuration with mysql_config command..."
-  libs = ['m', 'z', 'socket', 'nsl', 'mygcc']
+  begin
-  while not find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql") do
+    cflags = libs = nil
-    exit 1 if libs.empty?
+    
-    have_library(libs.shift)
+    dirs = ENV['PATH'].split(':') + %w[
+      /opt
+      /opt/local
+      /opt/local/mysql
+      /opt/local/lib/mysql5
+      /usr
+      /usr/local
+      /usr/local/mysql
+      /usr/local/mysql-*
+      /usr/local/lib/mysql5
+    ].map{|dir| "#{dir}/bin" }
+
+    GLOB = "{#{dirs.join(',')}}/{mysql_config,mysql_config5}"
+
+    if /mswin32/ =~ RUBY_PLATFORM
+      inc, lib = dir_config('mysql')
+      exit 1 unless have_library("libmysql")
+    elsif mc = (with_config('mysql-config') || Dir[GLOB].first) then
+      mc = Dir[GLOB].first if mc == true      
+      puts "Succeeded to detect MySQL configuration: #{mc}"
+      cflags = `#{mc} --cflags`.chomp
+      exit 1 if $? != 0
+      libs = `#{mc} --libs`.chomp
+      exit 1 if $? != 0
+      $CPPFLAGS += ' ' + cflags
+      $libs = libs + " " + $libs
+    else
+      puts "Failed to detect MySQL configuration with mysql_config command."
+      puts "Trying to detect MySQL client library..."
+      inc, lib = dir_config('mysql', '/usr/local')
+      libs = ['m', 'z', 'socket', 'nsl', 'mygcc']
+      while not find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql") do
+        #exit 1 if libs.empty?
+        !libs.empty?  or die "can't find mysql client library."
+        have_library(libs.shift)
+      end
+    end
+
   end
 end
 
@@ -28,11 +81,14 @@ if have_header('mysql.h') then
 elsif have_header('mysql/mysql.h') then
   src = "#include <mysql/errmsg.h>\n#include <mysql/mysqld_error.h>\n"
 else
-  exit 1
+  #exit 1
+  die "can't find 'mysql.h'."
 end
 
-if have_func('rb_thread_blocking_region') and have_macro('RB_UBF_DFL', 'ruby.h')
+# check for 1.9
-  cflags << "-DHAVE_TBR"
+if have_func('rb_thread_blocking_region') and have_macro('RUBY_UBF_IO', 'ruby.h')
+  $CFLAGS += " -DHAVE_TBR "
+  $CPPFLAGS << " -DHAVE_TBR "
 end
 
 # make mysql constant
@@ -47,9 +103,10 @@ end
 if /mswin32/ =~ RUBY_PLATFORM && !/-E/.match(cpp)
   cpp << " -E"
 end
-unless system "#{cpp} > confout" then
+#unless system "#{cpp} > confout" then
-  exit 1
+#  exit 1
-end
+#end
+exec_command("#{cpp} > confout")
 File.unlink "conftest.c"
 
 error_syms = []
@@ -71,4 +128,10 @@ File.open('error_const.h', 'w') do |f|
   end
 end
 
-create_makefile("mysql")
+$CPPFLAGS += " -DRUBY19" if RUBY_VERSION =~ /1.9/
+
+if hard_mysql_path = $libs[%r{-L(/[^ ]+)}, 1]
+	$LDFLAGS << " -Wl,-rpath,#{hard_mysql_path}"
+end
+
+create_makefile("mysql")

ext/mysql.c

@@ -6,16 +6,49 @@
 
 #include <ruby.h>
 #include <errno.h>
+#include <stdarg.h> 
 #ifndef RSTRING_PTR
 #define RSTRING_PTR(str) RSTRING(str)->ptr
 #endif
 #ifndef RSTRING_LEN
 #define RSTRING_LEN(str) RSTRING(str)->len
 #endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(ary) RARRAY(ary)->ptr
+#endif
 #ifndef HAVE_RB_STR_SET_LEN
 #define rb_str_set_len(str, length) (RSTRING_LEN(str) = (length))
 #endif
 
+#ifdef RUBY19
+#include <ruby/encoding.h>
+#define DEFAULT_ENCODING (rb_enc_get(rb_enc_default_external()))
+#else
+#define DEFAULT_ENCODING NULL
+#define rb_enc_str_new(ptr, len, enc) rb_str_new(ptr, len)
+#endif
+
+VALUE
+rb_enc_tainted_str_new(const char *ptr, long len)
+{
+    VALUE str = rb_enc_str_new(ptr, len, DEFAULT_ENCODING);
+
+    OBJ_TAINT(str);
+    return str;
+}
+
+VALUE
+rb_enc_tainted_str_new2(const char *ptr)
+{
+    VALUE str = rb_enc_str_new(ptr, strlen(ptr), DEFAULT_ENCODING);
+
+    OBJ_TAINT(str);
+    return str;
+}
+
+
+
+
 #ifdef HAVE_MYSQL_H
 #include <mysql.h>
 #include <mysql_com.h>
@@ -66,6 +99,7 @@ struct mysql {
     char busy;
 };
 
+// a wrapper for mysql_res's so we can detect double frees
 struct mysql_res {
     MYSQL_RES* res;
     char freed;
@@ -178,7 +212,7 @@ static void mysql_raise(MYSQL* m)
     VALUE e = rb_exc_new2(eMysql, mysql_error(m));
     rb_iv_set(e, "errno", INT2FIX(mysql_errno(m)));
 #if MYSQL_VERSION_ID >= 40101
-    rb_iv_set(e, "sqlstate", rb_tainted_str_new2(mysql_sqlstate(m)));
+    rb_iv_set(e, "sqlstate", rb_enc_tainted_str_new2(mysql_sqlstate(m)));
 #endif
     rb_exc_raise(e);
 }
@@ -193,9 +227,10 @@ static VALUE mysqlres2obj(MYSQL_RES* res, VALUE gc_disabled)
     resp->res = res;
     resp->freed = Qfalse;
     rb_obj_call_init(obj, 0, NULL);
-    if (++store_result_count > GC_STORE_RESULT_LIMIT && gc_disabled == Qfalse){
+    /* disabled until it can be reviewed further--rely on the normal GC for now.
-      rb_gc();
+    if (++store_result_count > GC_STORE_RESULT_LIMIT)
-	}
+	rb_gc();
+    */
     return obj;
 }
 
@@ -206,9 +241,9 @@ static VALUE make_field_obj(MYSQL_FIELD* f)
     if (f == NULL)
 	return Qnil;
     obj = rb_obj_alloc(cMysqlField);
-    rb_iv_set(obj, "name", f->name? rb_str_freeze(rb_tainted_str_new2(f->name)): Qnil);
+    rb_iv_set(obj, "name", f->name? rb_str_freeze(rb_enc_tainted_str_new2(f->name)): Qnil);
-    rb_iv_set(obj, "table", f->table? rb_str_freeze(rb_tainted_str_new2(f->table)): Qnil);
+    rb_iv_set(obj, "table", f->table? rb_str_freeze(rb_enc_tainted_str_new2(f->table)): Qnil);
-    rb_iv_set(obj, "def", f->def? rb_str_freeze(rb_tainted_str_new2(f->def)): Qnil);
+    rb_iv_set(obj, "def", f->def? rb_str_freeze(rb_enc_tainted_str_new2(f->def)): Qnil);
     rb_iv_set(obj, "type", INT2NUM(f->type));
     rb_iv_set(obj, "length", INT2NUM(f->length));
     rb_iv_set(obj, "max_length", INT2NUM(f->max_length));
@@ -231,11 +266,81 @@ static VALUE init(VALUE klass)
     mysql_init(&myp->handler);
     myp->connection = Qfalse;
     myp->query_with_result = Qtrue;
-    myp->gc_disabled = Qfalse;
+    myp->gc_disabled = Qtrue;
     rb_obj_call_init(obj, 0, NULL);
     return obj;
 }
 
+// =========== a 1.9 rb_thread_blocking_region simplifier attempt
+#ifdef HAVE_TBR
+
+typedef struct
+{
+ void *func_pointer;
+ int param_count;
+ void *args[10];
+} arg_holder, *arg_holder2;
+
+// here's how to make  rb_thread_blocking_region much cleaner and easier
+// syntax: param_count+2, func_pointer to call, [RUBY_UBF_IO or RUBY_UBF_PROCESS], param1, param2...
+// the third parameter is the interuptor--possible values appear to be RUBY_UBF_IO or RUBY_UBF_PROCESS http://groups.google.com/group/comp.lang.ruby/browse_thread/thread/ad8c1326b2a8e404/00447b9aa15979be?lnk=raot
+// ex: (int) returned_this = rb_thread_blocking_region_variable_params(10, &method_name, RUBY_UBF_IO, param1, param2, param3, param4, param5, param6, param7, param8)
+
+static void *call_single_function_rb_thread_blocking_region(void *arg_holder_in);
+
+void *rb_thread_blocking_region_variable_params(int number, ...)
+{
+  va_list param_pt;
+  va_start(param_pt, number);
+  int index;
+  arg_holder param_storer;
+  void *func_pointer = va_arg(param_pt, void *);
+  void *interrupter = va_arg(param_pt, void *);
+  param_storer.func_pointer = func_pointer;
+  int real_param_count = number - 2;
+  param_storer.param_count = real_param_count;
+  for(index = 0 ; index < real_param_count ; index++) 
+  {
+	void *arg = va_arg(param_pt, void *);
+	param_storer.args[index] = arg;
+
+  }
+  va_end(param_pt);
+
+  return (void *) rb_thread_blocking_region((rb_blocking_function_t *)call_single_function_rb_thread_blocking_region, (void *) &param_storer, interrupter, 0);
+
+}
+
+// used internally
+static void * call_single_function_rb_thread_blocking_region(void *arg_holder_in)
+{
+   arg_holder *params_and_func = (arg_holder *) arg_holder_in;
+   int param_count = params_and_func->param_count;
+   void *result;
+   switch(param_count)
+   {
+   case 3:;
+     void * (*pt3Func)(void *, void *, void *) = params_and_func->func_pointer;
+     result = (*pt3Func)(params_and_func->args[0], params_and_func->args[1], params_and_func->args[2]); 
+     break;
+   case 6:;
+	void * (*pt6Func)(void *, void *, void *, void *, void *, void *) = params_and_func->func_pointer;
+	result = (*pt6Func)(params_and_func->args[0], params_and_func->args[1], params_and_func->args[2], params_and_func->args[3], params_and_func->args[4], params_and_func->args[5]);
+	break;
+   case 8:;
+	void * (*pt8Func)(void *, void *, void *, void *, void *, void *, void *, void *) = params_and_func->func_pointer;
+	result = (*pt8Func)(params_and_func->args[0], params_and_func->args[1], params_and_func->args[2], params_and_func->args[3], params_and_func->args[4], params_and_func->args[5], params_and_func->args[6], params_and_func->args[7]);
+	break;
+   default:;
+	printf("UNknown param count--please add it! %d\n", param_count);
+        result = (void *) Qnil;
+   }
+
+   return result;
+}
+
+#endif
+
 static VALUE connection_identifier( VALUE obj )
 {
     MYSQL* m = GetHandler(obj);
@@ -255,6 +360,7 @@ static VALUE async_in_progress_set( VALUE obj, VALUE flag )
     return flag; 
 }
 
+// does this actually really do anything helpful? Not sure.
 static void optimize_for_async( VALUE obj )
 {
     struct mysql* m = GetMysqlStruct(obj);
@@ -266,16 +372,19 @@ static void optimize_for_async( VALUE obj )
     async_in_progress_set( obj, Qfalse );
 }
 
+// TODO does nothing currently
 static void schedule_connect(VALUE obj )
 {
+/* TODO is this old?
     MYSQL* m = GetHandler(obj);
     fd_set read;
 
     struct timeval tv = { tv_sec: m->options.connect_timeout, tv_usec: 0 };
-
     if (rb_thread_select(0, NULL, NULL, NULL, &tv) < 0) {
       rb_raise(eMysql, "connect: timeout");
     }
+*/
+
 /*
     FD_ZERO(&read);
     FD_SET(m->net.fd, &read);
@@ -313,8 +422,12 @@ static VALUE real_connect(int argc, VALUE* argv, VALUE klass)
 
     obj = Data_Make_Struct(klass, struct mysql, 0, free_mysql, myp);
 #if MYSQL_VERSION_ID >= 32200
-    mysql_init(&myp->handler);
+    mysql_init(&myp->handler); /* we get here */
-    if (mysql_real_connect(&myp->handler, h, u, p, d, pp, s, f) == NULL)
+# ifdef HAVE_TBR
+    if( (MYSQL *) rb_thread_blocking_region_variable_params(10, &mysql_real_connect, RUBY_UBF_IO, &myp->handler, h, u, p, d, pp, s, f) == NULL) 
+# else
+    if(mysql_real_connect(&myp->handler, h, u, p, d, pp, s, f) == NULL)
+# endif
 #elif MYSQL_VERSION_ID >= 32115
     if (mysql_real_connect(&myp->handler, h, u, p, pp, s, f) == NULL)
 #else
@@ -330,7 +443,7 @@ static VALUE real_connect(int argc, VALUE* argv, VALUE klass)
     myp->query_with_result = Qtrue;
     rb_obj_call_init(obj, argc, argv);
     
-    schedule_connect(obj);
+    //schedule_connect(obj);
 
     return obj;
 }
@@ -340,7 +453,7 @@ static VALUE escape_string(VALUE klass, VALUE str)
 {
     VALUE ret;
     Check_Type(str, T_STRING);
-    ret = rb_str_new(0, (RSTRING_LEN(str))*2+1);
+    ret = rb_enc_str_new(0, (RSTRING_LEN(str))*2+1, DEFAULT_ENCODING);
     rb_str_set_len(ret, mysql_escape_string(RSTRING_PTR(ret), RSTRING_PTR(str), RSTRING_LEN(str)));
     return ret;
 }
@@ -348,7 +461,7 @@ static VALUE escape_string(VALUE klass, VALUE str)
 /*	client_info()	*/
 static VALUE client_info(VALUE klass)
 {
-    return rb_tainted_str_new2(mysql_get_client_info());
+    return rb_enc_tainted_str_new2(mysql_get_client_info());
 }
 
 #if MYSQL_VERSION_ID >= 32332
@@ -395,7 +508,7 @@ static VALUE real_connect2(int argc, VALUE* argv, VALUE obj)
     GetMysqlStruct(obj)->connection = Qtrue;
          
     optimize_for_async(obj);
-    schedule_connect(obj);
+    //schedule_connect(obj);
 
     return obj;
 }
@@ -477,7 +590,7 @@ static VALUE real_escape_string(VALUE obj, VALUE str)
     MYSQL* m = GetHandler(obj);
     VALUE ret;
     Check_Type(str, T_STRING);
-    ret = rb_str_new(0, (RSTRING_LEN(str))*2+1);
+    ret = rb_enc_str_new(0, (RSTRING_LEN(str))*2+1, DEFAULT_ENCODING);
     rb_str_set_len(ret, mysql_real_escape_string(m, RSTRING_PTR(ret), RSTRING_PTR(str), RSTRING_LEN(str)));
     return ret;
 }
@@ -516,7 +629,7 @@ static VALUE change_user(int argc, VALUE* argv, VALUE obj)
 /*	character_set_name()	*/
 static VALUE character_set_name(VALUE obj)
 {
-    return rb_tainted_str_new2(mysql_character_set_name(GetHandler(obj)));
+    return rb_enc_tainted_str_new2(mysql_character_set_name(GetHandler(obj)));
 }
 #endif
 
@@ -581,7 +694,7 @@ static VALUE field_count(VALUE obj)
 /*	host_info()	*/
 static VALUE host_info(VALUE obj)
 {
-    return rb_tainted_str_new2(mysql_get_host_info(GetHandler(obj)));
+    return rb_enc_tainted_str_new2(mysql_get_host_info(GetHandler(obj)));
 }
 
 /*	proto_info()	*/
@@ -593,14 +706,14 @@ static VALUE proto_info(VALUE obj)
 /*	server_info()	*/
 static VALUE server_info(VALUE obj)
 {
-    return rb_tainted_str_new2(mysql_get_server_info(GetHandler(obj)));
+    return rb_enc_tainted_str_new2(mysql_get_server_info(GetHandler(obj)));
 }
 
 /*	info()		*/
 static VALUE info(VALUE obj)
 {
     const char* p = mysql_info(GetHandler(obj));
-    return p? rb_tainted_str_new2(p): Qnil;
+    return p? rb_enc_tainted_str_new2(p): Qnil;
 }
 
 /*	insert_id()	*/
@@ -635,7 +748,7 @@ static VALUE list_dbs(int argc, VALUE* argv, VALUE obj)
     n = mysql_num_rows(res);
     ret = rb_ary_new2(n);
     for (i=0; i<n; i++)
-	rb_ary_store(ret, i, rb_tainted_str_new2(mysql_fetch_row(res)[0]));
+	rb_ary_store(ret, i, rb_enc_tainted_str_new2(mysql_fetch_row(res)[0]));
     mysql_free_result(res);
     return ret;
 }
@@ -680,7 +793,7 @@ static VALUE list_tables(int argc, VALUE* argv, VALUE obj)
     n = mysql_num_rows(res);
     ret = rb_ary_new2(n);
     for (i=0; i<n; i++)
-	rb_ary_store(ret, i, rb_tainted_str_new2(mysql_fetch_row(res)[0]));
+	rb_ary_store(ret, i, rb_enc_tainted_str_new2(mysql_fetch_row(res)[0]));
     mysql_free_result(res);
     return ret;
 }
@@ -744,16 +857,42 @@ static VALUE my_stat(VALUE obj)
     const char* s = mysql_stat(m);
     if (s == NULL)
 	mysql_raise(m);
-    return rb_tainted_str_new2(s);
+    return rb_enc_tainted_str_new2(s);
+}
+
+// 1.9 friendly
+typedef struct
+{
+ MYSQL *mysql_instance;
+ MYSQL_RES **store_it_here;
+
+} mysql_result_to_here_t,
+ *shared_stuff_p;
+
+static VALUE store_result_to_location(void *settings_in)
+{
+   mysql_result_to_here_t *settings = (mysql_result_to_here_t *) settings_in;
+   *(settings->store_it_here) = mysql_store_result(settings->mysql_instance); // this one line runs a good long while for very large queries 
+   return Qnil;
 }
 
 /*	store_result()	*/
 static VALUE store_result(VALUE obj)
 {
     MYSQL* m = GetHandler(obj);
-    MYSQL_RES* res = mysql_store_result(m);
+    MYSQL_RES* res = NULL;
+#ifndef HAVE_TBR
+    res = mysql_store_result(m);
+#else
+    mysql_result_to_here_t linker;
+    linker.mysql_instance = m;
+    linker.store_it_here = &res;
+    rb_thread_blocking_region(store_result_to_location, (void *) &linker, RUBY_UBF_IO, 0);
+#endif
+ 
     if (res == NULL)
 	mysql_raise(m);
+
     return mysqlres2obj(res, GetMysqlStruct(obj)->gc_disabled);
 }
 
@@ -774,18 +913,43 @@ static VALUE use_result(VALUE obj)
 }
 
 static VALUE res_free(VALUE);
+
+typedef struct {
+	MYSQL *m;
+	const char *data;
+	unsigned long len;
+} QueryArgs;
+
+static VALUE blocking_query(void *data)
+{
+    QueryArgs *args = (QueryArgs *) data;
+    return (VALUE) mysql_real_query(args->m, args->data, args->len);
+}
+
 /*	query(sql)	*/
 static VALUE query(VALUE obj, VALUE sql)
 {
     int loop = 0;
     MYSQL* m = GetHandler(obj);
+    QueryArgs args;
+    int result;
+    
     Check_Type(sql, T_STRING);
     if (GetMysqlStruct(obj)->connection == Qfalse) {
         rb_raise(eMysql, "query: not connected");
     }
     if (rb_block_given_p()) {
-	if (mysql_real_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0)
+        #ifdef RUBY_VM
+	    args.m = m;
+	    args.data = RSTRING_PTR(sql);
+	    args.len = RSTRING_LEN(sql);
+	    result = (int) rb_thread_blocking_region(blocking_query, &args, RUBY_UBF_PROCESS, 0);
+	#else
+	    result = mysql_real_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql));
+	#endif
+	if (result != 0)
 	    mysql_raise(m);
+	
 	do {
 	    MYSQL_RES* res = mysql_store_result(m);
 	    if (res == NULL) {
@@ -804,7 +968,16 @@ static VALUE query(VALUE obj, VALUE sql)
 #endif
 	return obj;
     }
-    if (mysql_real_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0)
+    
+    #ifdef RUBY_VM
+	args.m = m;
+	args.data = RSTRING_PTR(sql);
+	args.len = RSTRING_LEN(sql);
+	result = (int) rb_thread_blocking_region(blocking_query, &args, RUBY_UBF_PROCESS, 0);
+    #else
+	result = mysql_real_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql));
+    #endif
+    if (result != 0)
 	mysql_raise(m);
     if (GetMysqlStruct(obj)->query_with_result == Qfalse)
 	return obj;
@@ -820,6 +993,16 @@ static VALUE socket(VALUE obj)
     return INT2NUM(m->net.fd);
 }
 
+/* socket_type --currently returns true or false, needs some work */
+static VALUE socket_type(VALUE obj)
+{
+    MYSQL* m = GetHandler(obj);
+    if(vio_description(m->net.vio))
+	return Qtrue; // TODO return a ruby string
+    else
+	return Qnil;
+}
+
 /* blocking */
 static VALUE blocking(VALUE obj){
     return ( GetMysqlStruct(obj)->blocking ? Qtrue : Qfalse );
@@ -863,7 +1046,7 @@ static VALUE readable( int argc, VALUE* argv, VALUE obj )
     if ( NIL_P( timeout ) ){
       timeout = m->net.read_timeout;
     }
-
+    // todo could do a rb_blocking_region here
     return ( vio_poll_read( m->net.vio, INT2NUM(timeout) ) == 0 ? Qtrue : Qfalse );
 }
 
@@ -905,42 +1088,20 @@ static VALUE gc_disabled( VALUE obj ){
 
 static void validate_async_query( VALUE obj )
 {
-  	MYSQL* m = GetHandler(obj);
-
     if( async_in_progress(obj) == Qtrue ){
       async_in_progress_set(obj, Qfalse);
       rb_raise(eMysql, "Query out of sequence: Each call to Mysql#send_query requires a successive Mysql#get_result.");
     }
 }
 
-static void simulate_disconnect( VALUE obj )
+/* for testing */
+static VALUE simulate_disconnect( VALUE obj )
 {
-    MYSQL* m = GetHandler(obj);
+    MYSQL* m = GetHandler(obj); 
     mysql_library_end();
+    return Qnil;
 }
 
-static int begins_with_insensitive(char *candidate, char *check_for_in_upper_case)
-{
-    /* skip  opening whitespace --tab is 11, newline is 12, cr is 15, space 32 */
-    char *where_at = candidate;
-    while( ((*where_at >= 11 && *where_at <= 15) || (*where_at == 32)) && (where_at != 0)) 
-  	  where_at++;
-
-    char *where_at_in_test = check_for_in_upper_case;
-    while(*where_at_in_test)
-    {
-  	  int candidate_char = *where_at;
-	  if(candidate_char == 0)
-		  return 0; /* end of line */
-	  if(candidate_char >= 97 && candidate_char < 122) /* then it's upper case --lower case ify it */
-		  candidate_char -= 32;
-          if(candidate_char != *where_at_in_test)
-		  return 0;
-	  where_at_in_test++;
-	  where_at++;
-	}
-    return 1;
-}
 
 /* send_query(sql) */
 static VALUE send_query(VALUE obj, VALUE sql)
@@ -959,29 +1120,17 @@ static VALUE send_query(VALUE obj, VALUE sql)
     if (mysql_send_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0){
       idle( obj );
       mysql_raise(m);
-	}
+    }
+    async_in_progress_set( obj, Qtrue );
 	
-	/* what about http://dev.mysql.com/doc/refman/5.0/en/implicit-commit.html and more? */
+    return Qnil;
-	if( 
-	  begins_with_insensitive(RSTRING_PTR(sql), "SET ") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "BEGIN") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "START TRANSACTION") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "ROLLBACK") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "LOCK ") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "UNLOCK ") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "USE ") ||
-	  begins_with_insensitive(RSTRING_PTR(sql), "COMMIT") )
-	  {
-		/* do not mark an async in progress --they used send_query for something that doesn't necessarily have a result--is this allowable? */
-	   async_in_progress_set( obj, Qfalse ); 
-	} else {
-	  async_in_progress_set( obj, Qtrue );
-	}
-	
-	return Qnil;
 }
 
-/* get_result */
+/* 
+  get_result
+  returns the mysql_result set (default) [i.e. all rows in said said]
+  or nil if query_with_result == false
+ */
 static VALUE get_result(VALUE obj)
 {
     MYSQL* m = GetHandler(obj);
@@ -999,9 +1148,11 @@ static VALUE get_result(VALUE obj)
     
     if (GetMysqlStruct(obj)->query_with_result == Qfalse)
       	return obj;
+
     if (mysql_field_count(m) == 0)
 	    return Qnil; 
-      return store_result(obj);
+
+    return store_result(obj);
 }
 
 static void schedule_query(VALUE obj, VALUE timeout)
@@ -1038,7 +1189,9 @@ static int should_schedule_query(){
     return rb_thread_alone() != 1;
 }
 
-/* async_query(sql,timeout=nil) */
+/* async_query(sql,timeout=nil)
+   optionally take a block
+ */
 static VALUE async_query(int argc, VALUE* argv, VALUE obj)
 {
     MYSQL* m = GetHandler(obj); 
@@ -1164,7 +1317,7 @@ static VALUE set_server_option(VALUE obj, VALUE option)
 static VALUE sqlstate(VALUE obj)
 {
     MYSQL *m = GetHandler(obj);
-    return rb_tainted_str_new2(mysql_sqlstate(m));
+    return rb_enc_tainted_str_new2(mysql_sqlstate(m));
 }
 #endif
 
@@ -1329,16 +1482,16 @@ static VALUE fetch_row(VALUE obj)
 	return Qnil;
     ary = rb_ary_new2(n);
     for (i=0; i<n; i++)
-	rb_ary_store(ary, i, row[i]? rb_tainted_str_new(row[i], lengths[i]): Qnil);
+	rb_ary_store(ary, i, row[i]? rb_enc_tainted_str_new(row[i], lengths[i]): Qnil);
     return ary;
 }
 
-/*	process_all_hashes (internal)	*/
+/*	process_all_hashes (internal helper)	*/
 static VALUE process_all_hashes(VALUE obj, VALUE with_table, int build_array, int yield)
 {
     MYSQL_RES* res = GetMysqlRes(obj);
     unsigned int n = mysql_num_fields(res);
-    VALUE ary;
+    VALUE ary = Qnil;
     if(build_array)
   	ary = rb_ary_new();
     MYSQL_ROW row = mysql_fetch_row(res); // grab one off the top, to determine the rows
@@ -1359,7 +1512,7 @@ static VALUE process_all_hashes(VALUE obj, VALUE with_table, int build_array, in
         if (colname == Qnil) {
             colname = rb_ary_new2(n);
             for (i=0; i<n; i++) {
-                VALUE s = rb_tainted_str_new2(fields[i].name);
+                VALUE s = rb_enc_tainted_str_new2(fields[i].name);
                 rb_obj_freeze(s);
                 rb_ary_store(colname, i, s);
             }
@@ -1372,7 +1525,7 @@ static VALUE process_all_hashes(VALUE obj, VALUE with_table, int build_array, in
             colname = rb_ary_new2(n);
             for (i=0; i<n; i++) {
                 int len = strlen(fields[i].table)+strlen(fields[i].name)+1;
-                VALUE s = rb_tainted_str_new(NULL, len);
+                VALUE s = rb_enc_tainted_str_new(NULL, len);
                 snprintf(RSTRING_PTR(s), len+1, "%s.%s", fields[i].table, fields[i].name);
                 rb_obj_freeze(s);
                 rb_ary_store(colname, i, s);
@@ -1388,7 +1541,7 @@ static VALUE process_all_hashes(VALUE obj, VALUE with_table, int build_array, in
       hash = rb_hash_new();
       lengths = mysql_fetch_lengths(res);
       for (i=0; i<n; i++) {
-        rb_hash_aset(hash, rb_ary_entry(colname, i), row[i]? rb_tainted_str_new(row[i], lengths[i]): Qnil);
+        rb_hash_aset(hash, rb_ary_entry(colname, i), row[i]? rb_enc_tainted_str_new(row[i], lengths[i]): Qnil);
       }
       if(build_array)
 	rb_ary_push(ary, hash);
@@ -1405,6 +1558,8 @@ static VALUE process_all_hashes(VALUE obj, VALUE with_table, int build_array, in
    
     if(yield)
 	return obj;
+
+    return Qnil; /* we should never get here -- this takes out a compiler warning */
 }
 
 /*	fetch_hash2 (internal)	*/
@@ -1422,12 +1577,12 @@ static VALUE fetch_hash2(VALUE obj, VALUE with_table)
 	return Qnil;
     hash = rb_hash_new();
 
-    if (with_table == Qfalse) {
+    if (with_table == Qnil || with_table == Qfalse) {
         colname = rb_iv_get(obj, "colname");
         if (colname == Qnil) {
             colname = rb_ary_new2(n);
             for (i=0; i<n; i++) {
-                VALUE s = rb_tainted_str_new2(fields[i].name);
+                VALUE s = rb_enc_tainted_str_new2(fields[i].name);
                 rb_obj_freeze(s);
                 rb_ary_store(colname, i, s);
             }
@@ -1440,7 +1595,7 @@ static VALUE fetch_hash2(VALUE obj, VALUE with_table)
             colname = rb_ary_new2(n);
             for (i=0; i<n; i++) {
                 int len = strlen(fields[i].table)+strlen(fields[i].name)+1;
-                VALUE s = rb_tainted_str_new(NULL, len);
+                VALUE s = rb_enc_tainted_str_new(NULL, len);
                 snprintf(RSTRING_PTR(s), len+1, "%s.%s", fields[i].table, fields[i].name);
                 rb_obj_freeze(s);
                 rb_ary_store(colname, i, s);
@@ -1450,7 +1605,7 @@ static VALUE fetch_hash2(VALUE obj, VALUE with_table)
         }
     }
     for (i=0; i<n; i++) {
-        rb_hash_aset(hash, rb_ary_entry(colname, i), row[i]? rb_tainted_str_new(row[i], lengths[i]): Qnil);
+        rb_hash_aset(hash, rb_ary_entry(colname, i), row[i]? rb_enc_tainted_str_new(row[i], lengths[i]): Qnil);
     }
     return hash;
 }
@@ -1582,7 +1737,7 @@ static VALUE field_hash(VALUE obj)
 static VALUE field_inspect(VALUE obj)
 {
     VALUE n = rb_iv_get(obj, "name");
-    VALUE s = rb_str_new(0, RSTRING_LEN(n) + 16);
+    VALUE s = rb_enc_str_new(0, RSTRING_LEN(n) + 16, DEFAULT_ENCODING);
     sprintf(RSTRING_PTR(s), "#<Mysql::Field:%s>", RSTRING_PTR(n));
     return s;
 }
@@ -1641,7 +1796,7 @@ static void mysql_stmt_raise(MYSQL_STMT* s)
 {
     VALUE e = rb_exc_new2(eMysql, mysql_stmt_error(s));
     rb_iv_set(e, "errno", INT2FIX(mysql_stmt_errno(s)));
-    rb_iv_set(e, "sqlstate", rb_tainted_str_new2(mysql_stmt_sqlstate(s)));
+    rb_iv_set(e, "sqlstate", rb_enc_tainted_str_new2(mysql_stmt_sqlstate(s)));
     rb_exc_raise(e);
 }
 
@@ -1788,12 +1943,12 @@ static VALUE stmt_execute(int argc, VALUE *argv, VALUE obj)
                     s->param.bind[i].buffer = &(s->param.buffer[i]);
                     t.second_part = 0;
                     t.neg = 0;
-                    t.second = FIX2INT(RARRAY(a)->ptr[0]);
+                    t.second = FIX2INT(rb_ary_entry(a, 0));
-                    t.minute = FIX2INT(RARRAY(a)->ptr[1]);
+                    t.minute = FIX2INT(rb_ary_entry(a, 1));
-                    t.hour = FIX2INT(RARRAY(a)->ptr[2]);
+                    t.hour = FIX2INT(rb_ary_entry(a, 2));
-                    t.day = FIX2INT(RARRAY(a)->ptr[3]);
+                    t.day = FIX2INT(rb_ary_entry(a, 3));
-                    t.month = FIX2INT(RARRAY(a)->ptr[4]);
+                    t.month = FIX2INT(rb_ary_entry(a, 4));
-                    t.year = FIX2INT(RARRAY(a)->ptr[5]);
+                    t.year = FIX2INT(rb_ary_entry(a, 5));
                     *(MYSQL_TIME*)&(s->param.buffer[i]) = t;
                 } else if (CLASS_OF(argv[i]) == cMysqlTime) {
                     MYSQL_TIME t;
@@ -1955,7 +2110,7 @@ static VALUE stmt_fetch(VALUE obj)
             case MYSQL_TYPE_NEWDECIMAL:
             case MYSQL_TYPE_BIT:
 #endif
-                v = rb_tainted_str_new(s->result.bind[i].buffer, s->result.length[i]);
+                v = rb_enc_tainted_str_new(s->result.bind[i].buffer, s->result.length[i]);
                 break;
             default:
                 rb_raise(rb_eTypeError, "unknown buffer_type: %d", s->result.bind[i].buffer_type);
@@ -2144,7 +2299,7 @@ static VALUE stmt_send_long_data(VALUE obj, VALUE col, VALUE data)
 static VALUE stmt_sqlstate(VALUE obj)
 {
     struct mysql_stmt* s = DATA_PTR(obj);
-    return rb_tainted_str_new2(mysql_stmt_sqlstate(s->stmt));
+    return rb_enc_tainted_str_new2(mysql_stmt_sqlstate(s->stmt));
 }
 
 /*-------------------------------
@@ -2670,4 +2825,4 @@ void Init_mysql(void)
     /* Mysql::Error constant */
 #define rb_define_mysql_const(s) rb_define_const(eMysql, #s, INT2NUM(s))
 #include "error_const.h"
-}
+}

lib/mysqlplus.rb

@@ -1,19 +1,23 @@
-require 'mysql'
+require File.dirname(__FILE__) + '/mysql' # load our version of mysql--note
+# if someone does a require 'mysql' after a require 'mysqlplus' then their screen will be littered with warnings
+# and the "old" mysql will override the "new" mysqlplus, so be careful.
 
+#
+# The mysqlplus library is a  [slightly updated] fork of the Mysql class, with asynchronous capability added
+# See http://www.kitebird.com/articles/ruby-mysql.html for details, as well as the test directory within the gem
+#
 class Mysql
   
-  def async_query(sql, timeout = nil)
+  def ruby_async_query(sql, timeout = nil) # known to deadlock TODO
     send_query(sql)
     select [ (@sockets ||= {})[socket] ||= IO.new(socket) ], nil, nil, nil
     get_result
   end
+
+  begin
+    alias_method :async_query, :c_async_query  
+  rescue NameError => e
+    raise LoadError.new("error loading mysqlplus--this may mean you ran a require 'mysql' before a require 'mysqplus', which must come first -- possibly also run gem uninstall mysql")
+  end
   
 end
-
-class Mysql::Result
-  def all_hashes
-    rows = []
-    each_hash { |row| rows << row }
-    rows
-  end
-end

mysqlplus.gemspec

@@ -1,29 +1,30 @@
 Gem::Specification.new do |s|
   s.name     = "mysqlplus"
-  s.version  = "0.1.0"
+  s.version  = "0.1.4"
-  s.date     = "2008-08-13"
+  s.date     = "2010-07-04"
-  s.summary  = "Enhanced Ruby MySQL driver"
+  s.summary  = "Enhanced Ruby MySQL driver with Ruby 1.9 encoding awareness"
-  s.email    = "oldmoe@gmail.com"
+  s.email    = "jeremysuriel@gmail.com"
-  s.homepage = "http://github.com/oldmoe/mysqlplus"
+  s.homepage = "http://github.com/jrmey/mysqlplus"
   s.description = "Enhanced Ruby MySQL driver"
   s.has_rdoc = true
-  s.authors  = ["Muhammad A. Ali"]
+  s.authors  = ["Muhammad A. Ali", "Jeremy Suriel", "John Bintz"]
   s.platform = Gem::Platform::RUBY
-  s.files    = [ 
+  s.files    = %w[
-		"mysqlplus.gemspec", 
+    README
-		"README",
+    Rakefile
-		"Rakefile",
+    TODO_LIST
-		"lib/mysqlplus.rb",
+    ext/error_const.h
-		"test/test_helper.rb",
+    ext/extconf.rb
-		"test/native_threaded_test.rb",
+    ext/mysql.c
-		"test/c_threaded_test.rb",
+    lib/mysqlplus.rb
-		"test/evented_test.rb",
+    mysqlplus.gemspec
-		"ext/error_const.h",
+  ] + Dir.glob('test/*')
-		"ext/extconf.rb",
-		"ext/mysql.c"
-	]
   s.rdoc_options = ["--main", "README"]
   s.extra_rdoc_files = ["README"]
   s.extensions << "ext/extconf.rb"
-end
 
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+  end
+end

test/RUN_ALL_TESTS.RB

@@ -0,0 +1,9 @@
+# I suppose if all the tests don't blow up, that probably means pass
+require 'mysqlplus'
+for file in Dir.glob('*_test.rb') do
+ puts 'testing ' + file
+ # fork so we don't run out of connections to the mysql db, as few tests ever clean up their old processes
+ pid = Process.fork { load file }
+ Process.wait(pid)
+end
+puts 'successful'

test/all_hashes_test.rb

@@ -1,8 +1,4 @@
-# shows the effect of using .all_hashes instead of looping on each hash 
+require 'create_test_db'
-# run it by substiting in a 'long' [many row] query for the query variable and toggling use_all_hashes here at the top
-# note that we load all the rows first, then run .all_hashes on the result [to see more easily the effect of all hashes]
-# on my machine and a 200_000 row table, it took 3.38s versus 3.65s
-require 'mysqlplus'
 
 use_the_all_hashes_method = true 
 
@@ -12,16 +8,15 @@ $start = Time.now
 
 $connections = []
 $count.times do  
-  $connections << Mysql.real_connect('localhost','root', '', 'local_leadgen_dev')
+  $connections << Mysql.real_connect('localhost','root', '', 'local_test_db')
 end
 
-puts 'connection pool ready'
 
 $threads = []
 $count.times do |i|
   $threads << Thread.new do
 
-    query = "select * from campus_zips"
+    query = "select * from test_table"
     puts "sending query on connection #{i}"
     conn = $connections[i]
     result = conn.async_query(query)

test/connect_failure2_test.rb

@@ -0,0 +1,22 @@
+# If this script returns without the word pass
+# you may have compiled mysqlplus using ruby and
+# run it using a different version of ruby
+
+if RUBY_VERSION >= "1.9.1"
+ require 'mysqlplus'
+ require 'socket'
+ require 'timeout'
+ TCPServer.new '0.0.0.0', 8002
+ Thread.new { 
+  sleep 2
+  print "pass"
+  system("kill -9 #{Process.pid}")
+ }
+ Timeout::timeout(1) {
+  # uncomment this line to do the 'real' test
+  # which hangs otherwise (blows up if code is bad, otherwise hangs)
+  Mysql.real_connect '127.0.0.1', 'root', 'pass', 'db', 8002
+ }
+ raise 'should never get here'
+end
+

test/connect_failure_test.rb

@@ -0,0 +1,17 @@
+require 'mysqlplus'
+begin
+  Mysql.real_connect('fakehost','root', '', 'local_leadgen_dev')
+rescue Mysql::Error
+end
+begin
+  Mysql.real_connect('localhost','root', '', 'faketable')
+rescue Mysql::Error
+end
+begin
+  Mysql.real_connect('localhost', 'root', 'pass', 'db', 3307)# bad port
+rescue Mysql::Error
+end
+
+print "pass"
+
+

test/create_test_db.rb

@@ -0,0 +1,22 @@
+# To run first execute:
+=begin
+create database local_test_db;
+use local_test_db;
+CREATE TABLE test_table (
+         c1 INT, 
+         c2 VARCHAR(20)
+     );
+=end
+# This script shows the effect of using .all_hashes instead of looping on each hash 
+# run it by substiting in a 'long' [many row] query for the query variable and toggling use_all_hashes here at the top
+# note that we load all the rows first, then run .all_hashes on the result [to see more easily the effect of all hashes]
+# on my machine and a 200_000 row table, it took 3.38s versus 3.65s for the old .each_hash way [note also that .each_hash is 
+# almost as fast, now, as .all_hashes--they've both been optimized]
+require 'mysqlplus'
+
+puts 'initing db'
+# init the DB
+conn = Mysql.real_connect('localhost', 'root', '', 'local_test_db')
+conn.query("delete from test_table")
+200_000.times {conn.query(" insert into test_table (c1, c2) values (3, 'ABCDEFG')")}
+puts 'connection pool ready'

test/gc_benchmark_test.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'mysqlplus'
 require 'benchmark'
 
@@ -38,4 +37,4 @@ Benchmark.bmbm do |x|
   end
 end
 
-puts $gc_stats.join( ' | ' )
+puts $gc_stats.join( ' | ' )

test/many_requests_test.rb

@@ -0,0 +1,6 @@
+require 'mysqlplus'
+a = Mysql.real_connect('localhost','root')
+100.times { a.query("select sleep(0)") }
+print "pass"
+
+

test/out_of_sync_test.rb

@@ -2,13 +2,13 @@ require File.dirname(__FILE__) + '/test_helper'
 
 m = Mysql.real_connect('localhost','root')
 m.reconnect = true
-
+$count = 0
 class << m
-  
   def safe_query( query )
     begin
       send_query( query )
     rescue => e
+      $count += 1
       puts e.message
     end
   end
@@ -25,7 +25,10 @@ m.connect('localhost','root')
 m.safe_query( 'select sleep(1)' )
 m.safe_query( 'select sleep(1)' )#raises
 m.simulate_disconnect
+raise unless $count == 3
 m.safe_query( 'BEGIN' )
-m.safe_query( 'select sleep(1)' )
+m.safe_query( 'select sleep(1)' ) # raises
 m.get_result()
-m.safe_query( 'COMMIT' )
+m.safe_query( 'COMMIT' )
+m.get_result
+raise unless $count == 4

test/query_with_result_false_test.rb

@@ -5,8 +5,7 @@
 # from .82s to .62s
 # you can experiment with it by changing the query here to be a long one, and toggling the do_the_use_query_optimization variable
 # this also has the interesting property of 'freeing' Ruby to do thread changes mid-query.
-
+require 'create_test_db'
-require 'mysqlplus'
 
 do_the_use_query_optimization = true
 
@@ -16,7 +15,7 @@ $start = Time.now
 
 $connections = []
 $count.times do  
-  $connections << Mysql.real_connect('localhost','root', '', 'local_leadgen_dev')
+  $connections << Mysql.real_connect('localhost','root', '', 'local_test_db')
 end
 
 puts 'connection pool ready'
@@ -28,7 +27,7 @@ $count.times do |i|
     puts "sending query on connection #{i}"
     conn = $connections[i]
     saved = []
-    query = "select * from campus_zips"
+    query = "select * from test_table"
     if do_the_use_query_optimization
       conn.query_with_result=false
       result = conn.async_query(query)

test/test_helper.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'mysqlplus'
 
 class MysqlTest
@@ -196,4 +195,4 @@ class ThreadedMysqlTest < MysqlTest
     end
   end
   
-end
+end

test/threaded_sequel_test.rb

@@ -1,7 +1,7 @@
+require 'mysqlplus'
 require 'rubygems'
 require 'sequel'
 
-require 'mysqlplus'
 class Mysql
   unless method_defined? :sync_query
     alias :sync_query :query
@@ -21,4 +21,4 @@ start = Time.now
   end
 end.map{|t| t.join }
 
-p (Time.now - start)
+p (Time.now - start)