mysqlplus 0.1.1 → 0.1.2

data/README

@@ -29,6 +29,10 @@ An enhanced MySQL database driver. With support for async operations and threade
   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
 
 Aman Gupta, for help in threading support and improved tests
@@ -38,3 +42,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

data/TODO_LIST

@@ -1,13 +1,12 @@
 TODO list:
 
-Is there a quick, cheap, easy way to test for writability so we don't have to use select on the way in? Does it take long anyway?
+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?
 
-Docs for how to use with rails, etc. [there is mysqlplus_adapter, so maybe we're good there].
+Some of the tests currently might "think" they are using the ruby select but in reality be using the C select.
 
-Merge in lourens' branch -- I like the double check for not using send_query twice in a row! [rdp]
+gc_disabled is unused
 
-look into http://coderrr.wordpress.com/2009/01/11/ruby-and-mysqlplus-select-deadlock/
+if they call get_result twice consecutively it should blow (and maybe already does).
 
-Some of the test/* anticipate a certain database existing--todo create it first, then drop it [?]
-
-critical todo list:
+mingw support
+add slim attributes right in there :)

data/ext/error_const.h

@@ -533,4 +533,7 @@
     rb_define_mysql_const(ER_ADMIN_WRONG_MRG_TABLE);
     rb_define_mysql_const(ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT);
     rb_define_mysql_const(ER_NAME_BECOMES_EMPTY);
+    rb_define_mysql_const(ER_AMBIGUOUS_FIELD_TERM);
+    rb_define_mysql_const(ER_LOAD_DATA_INVALID_COLUMN);
+    rb_define_mysql_const(ER_LOG_PURGE_NO_FILE);
     rb_define_mysql_const(ER_ERROR_LAST);

data/ext/extconf.rb

@@ -45,8 +45,10 @@ else
   exit 1
 end
 
+# check for 1.9
 if have_func('rb_thread_blocking_region') and have_macro('RUBY_UBF_IO', 'ruby.h')
-  $CPPFLAGS << " -DHAVE_TBR"
+  $CFLAGS += " -DHAVE_TBR "
+  $CPPFLAGS << " -DHAVE_TBR "
 end
 
 # make mysql constant
@@ -85,4 +87,4 @@ File.open('error_const.h', 'w') do |f|
   end
 end
 
-create_makefile("mysql")
+create_makefile("mysql")

data/ext/mysql.c

@@ -6,6 +6,7 @@
 
 #include <ruby.h>
 #include <errno.h>
+#include <stdarg.h> 
 #ifndef RSTRING_PTR
 #define RSTRING_PTR(str) RSTRING(str)->ptr
 #endif
@@ -60,9 +61,13 @@ struct mysql {
     MYSQL handler;
     char connection;
     char query_with_result;
+    char gc_disabled;
     char blocking;
+    int async_in_progress;
+    char busy;
 };
 
+// a wrapper for mysql_res's so we can detect double frees
 struct mysql_res {
     MYSQL_RES* res;
     char freed;
@@ -180,7 +185,7 @@ static void mysql_raise(MYSQL* m)
     rb_exc_raise(e);
 }
 
-static VALUE mysqlres2obj(MYSQL_RES* res)
+static VALUE mysqlres2obj(MYSQL_RES* res, VALUE gc_disabled)
 {
     VALUE obj;
     struct mysql_res* resp;
@@ -229,10 +234,135 @@ static VALUE init(VALUE klass)
     mysql_init(&myp->handler);
     myp->connection = Qfalse;
     myp->query_with_result = Qtrue;
+    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);
+    return mysql_thread_id( m );
+}
+
+static VALUE async_in_progress( VALUE obj )
+{
+   struct mysql* m = GetMysqlStruct(obj);
+   return ( m->async_in_progress == connection_identifier(obj) ) ? Qtrue : Qfalse;
+}
+
+static VALUE async_in_progress_set( VALUE obj, VALUE flag )
+{
+    struct mysql* m = GetMysqlStruct(obj);
+    m->async_in_progress = (flag == Qnil || flag == Qfalse) ? 0 : connection_identifier(obj);
+    return flag; 
+}
+
+// does this actually really do anything helpful? Not sure.
+static void optimize_for_async( VALUE obj )
+{
+    struct mysql* m = GetMysqlStruct(obj);
+    my_bool was_blocking;
+    vio_blocking(m->handler.net.vio, 0, &was_blocking);    
+    m->blocking = vio_is_blocking( m->handler.net.vio );
+
+    vio_fastsend( m->handler.net.vio );
+    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);
+
+    if (rb_thread_select(m->net.fd + 1, &read, NULL, NULL, &tv) < 0) {
+      rb_raise(eMysql, "connect: timeout");
+    }
+*/
+}
+
 /*	real_connect(host=nil, user=nil, passwd=nil, db=nil, port=nil, sock=nil, flag=nil)	*/
 static VALUE real_connect(int argc, VALUE* argv, VALUE klass)
 {
@@ -260,27 +390,28 @@ 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);
-    if (mysql_real_connect(&myp->handler, h, u, p, d, pp, s, f) == NULL)
+    mysql_init(&myp->handler); /* we get here */
+# 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
     if (mysql_real_connect(&myp->handler, h, u, p, pp, s) == NULL)
 #endif
 	mysql_raise(&myp->handler);
-
+    
     myp->handler.reconnect = 0;
     myp->connection = Qtrue;
 
-    my_bool was_blocking;
-
-    vio_blocking(myp->handler.net.vio, 0, &was_blocking);    
-    myp->blocking = vio_is_blocking( myp->handler.net.vio );
-
-    vio_fastsend( myp->handler.net.vio );
+    optimize_for_async(obj);
 
     myp->query_with_result = Qtrue;
     rb_obj_call_init(obj, argc, argv);
+    
+    //schedule_connect(obj);
 
     return obj;
 }
@@ -343,6 +474,9 @@ static VALUE real_connect2(int argc, VALUE* argv, VALUE obj)
 	mysql_raise(m);
     m->reconnect = 0;
     GetMysqlStruct(obj)->connection = Qtrue;
+         
+    optimize_for_async(obj);
+    //schedule_connect(obj);
 
     return obj;
 }
@@ -597,7 +731,7 @@ static VALUE list_fields(int argc, VALUE* argv, VALUE obj)
     res = mysql_list_fields(m, StringValuePtr(table), NILorSTRING(field));
     if (res == NULL)
 	mysql_raise(m);
-    return mysqlres2obj(res);
+    return mysqlres2obj(res, GetMysqlStruct(obj)->gc_disabled);
 }
 
 /*	list_processes()	*/
@@ -607,7 +741,7 @@ static VALUE list_processes(VALUE obj)
     MYSQL_RES* res = mysql_list_processes(m);
     if (res == NULL)
 	mysql_raise(m);
-    return mysqlres2obj(res);
+    return mysqlres2obj(res, GetMysqlStruct(obj)->gc_disabled);
 }
 
 /*	list_tables(table=nil)	*/
@@ -694,14 +828,40 @@ static VALUE my_stat(VALUE obj)
     return rb_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);
+
+    return mysqlres2obj(res, GetMysqlStruct(obj)->gc_disabled);
 }
 
 /*	thread_id()	*/
@@ -717,7 +877,7 @@ static VALUE use_result(VALUE obj)
     MYSQL_RES* res = mysql_use_result(m);
     if (res == NULL)
 	mysql_raise(m);
-    return mysqlres2obj(res);
+    return mysqlres2obj(res, GetMysqlStruct(obj)->gc_disabled);
 }
 
 static VALUE res_free(VALUE);
@@ -764,7 +924,7 @@ static VALUE query(VALUE obj, VALUE sql)
 		if (mysql_field_count(m) != 0)
 		    mysql_raise(m);
 	    } else {
-		VALUE robj = mysqlres2obj(res);
+		VALUE robj = mysqlres2obj(res, GetMysqlStruct(obj)->gc_disabled);
 		rb_ensure(rb_yield, robj, res_free, robj);
 	    }
 #if MYSQL_VERSION_ID >= 40101
@@ -800,17 +960,46 @@ static VALUE socket(VALUE obj)
     MYSQL* m = GetHandler(obj);
     return INT2NUM(m->net.fd);
 }
-/* socket_type */
+
+/* socket_type --currently returns true or false, needs some work */
 static VALUE socket_type(VALUE obj)
 {
     MYSQL* m = GetHandler(obj);
-    VALUE description = vio_description( m->net.vio );
-    return (VALUE) NILorSTRING( description );
+    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 );
+    return ( GetMysqlStruct(obj)->blocking ? Qtrue : Qfalse );
+}
+
+/* is_busy */
+static VALUE is_busy(VALUE obj){
+    return ( GetMysqlStruct(obj)->busy ? Qtrue : Qfalse );
+}
+
+static VALUE is_idle(VALUE obj){
+    return ( is_busy(obj) == Qtrue ) ? Qfalse : Qtrue;
+}
+
+/* busy(true|false) */
+static VALUE busy_set(VALUE obj, VALUE flag)
+{
+    if (TYPE(flag) != T_TRUE && TYPE(flag) != T_FALSE)
+        rb_raise(rb_eTypeError, "invalid type, required true or false.");
+    GetMysqlStruct(obj)->busy = flag;
+    return flag;
+}
+
+static void busy( VALUE obj ){
+    busy_set( obj, Qtrue );
+}
+
+static void idle( VALUE obj ){
+    busy_set( obj, Qfalse );
 }
 
 /* readable(timeout=nil) */
@@ -825,69 +1014,177 @@ 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 );
 }
 
+/* retry */
+static VALUE retry( VALUE obj )
+{
+    MYSQL* m = GetHandler(obj);
+    return ( vio_should_retry( m->net.vio ) == 1 ? Qtrue : Qfalse );
+}
+
+/* interrupted */
+static VALUE interrupted( VALUE obj )
+{
+    MYSQL* m = GetHandler(obj);
+    return ( vio_was_interrupted( m->net.vio ) == 1 ? Qtrue : Qfalse );
+}
+
+/* reconnected */
+static VALUE reconnected( VALUE obj ){
+    MYSQL* m = GetHandler(obj);
+    int current_connection_id = mysql_thread_id( m );
+    mysql_ping(m);
+    return ( current_connection_id == mysql_thread_id( m ) ) ? Qfalse : Qtrue;
+}
+
+/* disable_gc(true|false) */
+static VALUE disable_gc_set(VALUE obj, VALUE flag)
+{
+    if (TYPE(flag) != T_TRUE && TYPE(flag) != T_FALSE)
+        rb_raise(rb_eTypeError, "invalid type, required true or false.");
+    GetMysqlStruct(obj)->gc_disabled = flag;
+    return flag;
+}
+
+/* gc_disabled */
+static VALUE gc_disabled( VALUE obj ){
+    return GetMysqlStruct(obj)->gc_disabled ? Qtrue: Qfalse;  
+}
+
+static void validate_async_query( VALUE 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.");
+    }
+}
+
+/* for testing */
+static VALUE simulate_disconnect( VALUE obj )
+{
+    MYSQL* m = GetHandler(obj); 
+    mysql_library_end();
+    return Qnil;
+}
+
+
 /* send_query(sql) */
 static VALUE send_query(VALUE obj, VALUE sql)
 {
     MYSQL* m = GetHandler(obj);
-
+   
     Check_Type(sql, T_STRING);
-    if (GetMysqlStruct(obj)->connection == Qfalse) {
-        rb_raise(eMysql, "query: not connected");
+
+    if (GetMysqlStruct(obj)->connection == Qfalse && async_in_progress(obj) == Qtrue ) {
+      idle( obj );
+      rb_raise(eMysql, "query: not connected");
     }
-	  if (mysql_send_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0)
-	      mysql_raise(m);
-	  return Qnil;
+
+    validate_async_query(obj);
+
+    if (mysql_send_query(m, RSTRING_PTR(sql), RSTRING_LEN(sql)) != 0){
+      idle( obj );
+      mysql_raise(m);
+    }
+    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);
+
+    async_in_progress_set( obj, Qfalse );
+
     if (GetMysqlStruct(obj)->connection == Qfalse) {
-        rb_raise(eMysql, "query: not connected");
+       idle( obj );    
+       rb_raise(eMysql, "query: not connected");
     }
-	  if (mysql_read_query_result(m) != 0)
-	      mysql_raise(m);
+	if (mysql_read_query_result(m) != 0){
+	   idle( obj );    
+ 	   mysql_raise(m);
+	}
+    
     if (GetMysqlStruct(obj)->query_with_result == Qfalse)
       	return obj;
+
     if (mysql_field_count(m) == 0)
-	      return Qnil;
+	    return Qnil; 
+
     return store_result(obj);
 }
 
-static void schedule(VALUE obj, VALUE timeout)
+static void schedule_query(VALUE obj, VALUE timeout)
 {
     MYSQL* m = GetHandler(obj);
     fd_set read;
-
+    int ret;
+ 
     timeout = ( NIL_P(timeout) ? m->net.read_timeout : INT2NUM(timeout) );
 
     struct timeval tv = { tv_sec: timeout, tv_usec: 0 };
 
-    FD_ZERO(&read);
-    FD_SET(m->net.fd, &read);
+    for(;;){
+      FD_ZERO(&read);
+      FD_SET(m->net.fd, &read);
+ 
+      ret = rb_thread_select(m->net.fd + 1, &read, NULL, NULL, &tv);
+      if (ret < 0) {
+        idle( obj );    
+        rb_raise(eMysql, "query: timeout");
+      }
+	  
+	  if (ret == 0) {
+        continue;
+      }
 
-    if (rb_thread_select(m->net.fd + 1, &read, NULL, NULL, &tv) < 0) {
-      rb_raise(eMysql, "query: timeout");
+      if (m->status == MYSQL_STATUS_READY){
+        break;
+      }       
     }
 }
 
-/* async_query(sql,timeout=nil) */
+static int should_schedule_query(){
+    return rb_thread_alone() != 1;
+}
+
+/* async_query(sql,timeout=nil)
+   optionally take a block
+ */
 static VALUE async_query(int argc, VALUE* argv, VALUE obj)
 {
-  VALUE sql, timeout;
+    MYSQL* m = GetHandler(obj); 
+    VALUE sql, timeout;
+
+    rb_scan_args(argc, argv, "11", &sql, &timeout);
 
-  rb_scan_args(argc, argv, "11", &sql, &timeout);
+    async_in_progress_set( obj, Qfalse );
 
-  send_query(obj,sql);
+    busy(obj); 
 
-  schedule(obj, timeout);
+    send_query( obj, sql );
 
-  return get_result(obj);
+    if ( should_schedule_query() ){
+      schedule_query(obj, timeout);
+    } 
+
+    if (rb_block_given_p()) {
+      rb_yield( get_result(obj) );
+      idle( obj );
+      return obj; 
+    }else{
+      idle( obj );
+      return get_result(obj); 
+    }  
 }
 
 #if MYSQL_VERSION_ID >= 40100
@@ -1157,7 +1454,7 @@ static VALUE fetch_row(VALUE obj)
     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);
@@ -1922,7 +2219,7 @@ static VALUE stmt_result_metadata(VALUE obj)
 	mysql_stmt_raise(s->stmt);
       return Qnil;
     }
-    return mysqlres2obj(res);
+    return mysqlres2obj(res, Qfalse);
 }
 
 /*	row_seek(offset)	*/
@@ -2180,12 +2477,22 @@ void Init_mysql(void)
     rb_define_method(cMysql, "query", query, 1);
     rb_define_method(cMysql, "real_query", query, 1);
     rb_define_method(cMysql, "c_async_query", async_query, -1);
+    rb_define_method(cMysql, "async_in_progress?", async_in_progress, 0);
+    rb_define_method(cMysql, "async_in_progress=", async_in_progress_set, 1);
     rb_define_method(cMysql, "send_query", send_query, 1);
+    rb_define_method(cMysql, "simulate_disconnect", simulate_disconnect, 0);
+    rb_define_method(cMysql, "reconnected?", reconnected, 0);
     rb_define_method(cMysql, "get_result", get_result, 0);
     rb_define_method(cMysql, "readable?", readable, -1);
+    rb_define_method(cMysql, "retry?", retry, 0);
+    rb_define_method(cMysql, "interrupted?", interrupted, 0);
     rb_define_method(cMysql, "blocking?", blocking, 0);
+    rb_define_method(cMysql, "gc_disabled?", gc_disabled, 0);
+    rb_define_method(cMysql, "disable_gc=", disable_gc_set, 1);
+    rb_define_method(cMysql, "busy?", is_busy, 0);
+    rb_define_method(cMysql, "idle?", is_idle, 0);
+    rb_define_method(cMysql, "busy=", busy_set, 1);
     rb_define_method(cMysql, "socket", socket, 0);
-    rb_define_method(cMysql, "socket_type", socket_type, 0);
     rb_define_method(cMysql, "refresh", refresh, 1);
     rb_define_method(cMysql, "reload", reload, 0);
     rb_define_method(cMysql, "select_db", select_db, 1);

data/lib/mysqlplus.rb

@@ -1,8 +1,10 @@
-require 'mysql' # this should load the mysqlplus version of mysql.so, as we assume the user has installed mysql as a gem and have not done any previous "require 'mysql'" to have loaded the other
+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.
 
 #
-# Mysqlplus library gives you a [slightly modified] version of the Mysql class
-# See http://www.kitebird.com/articles/ruby-mysql.html for details, as well as the test directory within the library
+# 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
   
@@ -15,7 +17,7 @@ class Mysql
   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 much come first"
+    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

data/mysqlplus.gemspec

@@ -1,13 +1,13 @@
 Gem::Specification.new do |s|
   s.name     = "mysqlplus"
-  s.version  = "0.1.1"
+  s.version  = "0.1.2"
   s.date     = "2009-03-22"
   s.summary  = "Enhanced Ruby MySQL driver"
   s.email    = "oldmoe@gmail.com"
   s.homepage = "http://github.com/oldmoe/mysqlplus"
   s.description = "Enhanced Ruby MySQL driver"
   s.has_rdoc = true
-  s.authors  = ["Muhammad A. Ali"]
+  s.authors  = ["Muhammad A. Ali et al"]
   s.platform = Gem::Platform::RUBY
   s.files    = %w[
     README
@@ -18,18 +18,13 @@ Gem::Specification.new do |s|
     ext/mysql.c
     lib/mysqlplus.rb
     mysqlplus.gemspec
-    test/c_threaded_test.rb
-    test/evented_test.rb
-    test/native_threaded_test.rb
-    test/test_all_hashes.rb
-    test/test_failure.rb
-    test/test_helper.rb
-    test/test_many_requests.rb
-    test/test_parsing_while_response_is_being_read.rb
-    test/test_threaded_sequel.rb
-  ]
+  ] + Dir.glob('test/*')
   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

data/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'

data/test/{test_all_hashes.rb → all_hashes_test.rb}

@@ -1,9 +1,4 @@
-# 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
-require 'rubygems'
-require 'mysqlplus'
+require 'create_test_db'
 
 use_the_all_hashes_method = true 
 
@@ -13,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)

data/test/async_query_with_block_test.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+m = Mysql.real_connect('localhost','root','','mysql')
+
+m.c_async_query( 'SELECT * FROM user' ) do |result|
+  puts result.inspect
+end  

data/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
+

data/test/{test_failure.rb → connect_failure_test.rb}

@@ -1,4 +1,3 @@
-require 'rubygems'
 require 'mysqlplus'
 begin
   Mysql.real_connect('fakehost','root', '', 'local_leadgen_dev')
@@ -12,6 +11,7 @@ begin
   Mysql.real_connect('localhost', 'root', 'pass', 'db', 3307)# bad port
 rescue Mysql::Error
 end
+
 print "pass"
 
 

data/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'

data/test/gc_benchmark_test.rb

@@ -0,0 +1,40 @@
+require 'mysqlplus'
+require 'benchmark'
+
+with_gc = Mysql.real_connect('localhost','root','','mysql')
+without_gc = Mysql.real_connect('localhost','root','','mysql')
+without_gc.disable_gc = true
+
+$gc_stats = []
+
+def countable_gc?
+  GC.respond_to? :count
+end
+
+def gc_counts( label, scope )
+  $gc_stats << "Objects #{scope} ( #{label} ) #{GC.count}"
+end
+
+def with_gc_counts( label )
+  gc_counts( label, 'before' ) if countable_gc?
+  yield
+  gc_counts( label, 'after' ) if countable_gc?
+end
+
+n = 1000
+
+Benchmark.bmbm do |x|
+  x.report( 'With GC' ) do
+    with_gc_counts( 'With GC' ) do
+      n.times{ with_gc.c_async_query( 'SELECT * FROM user' ) }
+    end
+  end  
+  GC.start  
+  x.report( 'Without GC' ) do
+    with_gc_counts( 'Without GC' ) do
+      n.times{ without_gc.c_async_query( 'SELECT * FROM user' ) }
+    end
+  end
+end
+
+puts $gc_stats.join( ' | ' )

data/test/{test_many_requests.rb → many_requests_test.rb}

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

data/test/out_of_sync_test.rb

@@ -0,0 +1,34 @@
+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
+  
+end
+
+m.safe_query( 'select sleep(1)' )
+m.safe_query( 'select sleep(1)' )#raises
+m.simulate_disconnect #fires mysql_library_end
+m.safe_query( 'select sleep(1)' )
+m.safe_query( 'select sleep(1)' )#raises
+m.close
+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)' ) # raises
+m.get_result()
+m.safe_query( 'COMMIT' )
+m.get_result
+raise unless $count == 4

data/test/{test_parsing_while_response_is_being_read.rb → 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 'rubygems'
-require 'mysqlplus'
+require 'create_test_db'
 
 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)

data/test/reconnected_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+$m = Mysql.real_connect('localhost','root')
+#$m.reconnect = true
+
+def assert_reconnected
+  puts $m.reconnected?().inspect
+  sleep 1
+  yield
+  puts $m.reconnected?().inspect
+end
+
+assert_reconnected do
+  $m.simulate_disconnect
+end
+assert_reconnected do
+  $m.close
+end

data/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

data/test/{test_threaded_sequel.rb → 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)

metadata

@@ -1,15 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: mysqlplus
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
-- Muhammad A. Ali
+- Muhammad A. Ali et al
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-03-22 00:00:00 -07:00
+date: 2009-03-22 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -30,17 +35,26 @@ files:
 - ext/mysql.c
 - lib/mysqlplus.rb
 - mysqlplus.gemspec
+- test/all_hashes_test.rb
+- test/async_query_with_block_test.rb
+- test/connect_failure2_test.rb
+- test/connect_failure_test.rb
+- test/create_test_db.rb
 - test/c_threaded_test.rb
 - test/evented_test.rb
+- test/gc_benchmark_test.rb
+- test/many_requests_test.rb
 - test/native_threaded_test.rb
-- test/test_all_hashes.rb
-- test/test_failure.rb
+- test/out_of_sync_test.rb
+- test/query_with_result_false_test.rb
+- test/reconnected_test.rb
+- test/RUN_ALL_TESTS.RB
 - test/test_helper.rb
-- test/test_many_requests.rb
-- test/test_parsing_while_response_is_being_read.rb
-- test/test_threaded_sequel.rb
+- test/threaded_sequel_test.rb
 has_rdoc: true
 homepage: http://github.com/oldmoe/mysqlplus
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
@@ -51,20 +65,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.6
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Enhanced Ruby MySQL driver
 test_files: []