do_mysql 0.9.9 → 0.9.10

data/.gitignore

@@ -1,4 +0,0 @@
-pkg
-ext-java/target
-Makefile
-mkmf.log

data/Manifest.txt

@@ -9,8 +9,8 @@ buildfile
 ext-java/src/main/java/DoMysqlExtService.java
 ext-java/src/main/java/do_mysql/MySqlDriverDefinition.java
 ext/.gitignore
-ext/do_mysql_ext.c
-ext/extconf.rb
+ext/do_mysql_ext/do_mysql_ext.c
+ext/do_mysql_ext/extconf.rb
 lib/do_mysql.rb
 lib/do_mysql/transaction.rb
 lib/do_mysql/version.rb

data/Rakefile

@@ -1,44 +1,67 @@
+require 'pathname'
 require 'rubygems'
 require 'spec/rake/spectask'
-require 'pathname'
-
-ROOT = Pathname(__FILE__).dirname.expand_path
+require 'lib/do_mysql/version'
 
-require "lib/do_mysql/version"
 
-JRUBY   = (RUBY_PLATFORM =~ /java/) rescue nil
-WINDOWS = (RUBY_PLATFORM =~ /mswin|mingw|cygwin/) rescue nil
-          # don't use SUDO with JRuby, for the moment, although this behaviour
-          # is not entirely correct.
+ROOT    = Pathname(__FILE__).dirname.expand_path
+JRUBY   = RUBY_PLATFORM =~ /java/
+WINDOWS = Gem.win_platform?
 SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
 
 AUTHOR = "Scott Bauer"
 EMAIL  = "bauer.mail@gmail.com"
 GEM_NAME = "do_mysql"
 GEM_VERSION = DataObjects::Mysql::VERSION
-GEM_DEPENDENCIES = [["data_objects", GEM_VERSION]]
+GEM_DEPENDENCIES = if JRUBY
+  [["data_objects", GEM_VERSION], ["do_jdbc", GEM_VERSION], ["jdbc-mysql", ">=5.0.4"]]
+else
+  [["data_objects", GEM_VERSION]]
+end
 GEM_CLEAN = ['**/*.{o,so,bundle,log,a,gem,dSYM,obj,pdb,lib,def,exp,DS_Store}', 'ext/Makefile']
-GEM_EXTRAS = { :extensions => %w[ ext/extconf.rb ], :has_rdoc => false }
+GEM_EXTRAS = { :has_rdoc => false, :extensions => 'ext/do_mysql_ext/extconf.rb' }
 
 PROJECT_NAME = "dorb"
 PROJECT_URL  = "http://rubyforge.org/projects/dorb"
 PROJECT_DESCRIPTION = PROJECT_SUMMARY = "A DataObject.rb driver for MySQL"
 
-DRIVER = true
+JAVA_DRIVER = true
+
+
+# RCov is run by default, except on the JRuby platform, or if NO_RCOV env is true
+RUN_RCOV = JRUBY ? false : (ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true)
 
 if (tasks_dir = ROOT.parent + 'tasks').directory?
   require tasks_dir + 'hoe'
 end
 
+# compile the extension
+begin
+  gem('rake-compiler')
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new('do_mysql_ext', HOE.spec)
+rescue LoadError
+  warn "To cross-compile, install rake-compiler (gem install rake-compiler)"
+  if tasks_dir.directory?
+    require tasks_dir + 'ext_helper'
+    setup_extension('do_mysql_ext', HOE.spec)
+  end
+end
+
+def sudo_gem(cmd)
+  sh "#{SUDO} #{RUBY} -S gem #{cmd}", :verbose => false
+end
+
 # Installation
 
+desc "Install #{GEM_NAME} #{GEM_VERSION}"
 task :install => [ :package ] do
-  sh %{#{SUDO} gem install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources}, :verbose => false
+  sudo_gem "install pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
 end
 
-desc "Uninstall #{GEM_NAME} #{GEM_VERSION} (default ruby)"
+desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"
 task :uninstall => [ :clobber ] do
-  sh "#{SUDO} gem uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x", :verbose => false
+  sudo_gem "uninstall #{GEM_NAME} -v#{GEM_VERSION} -I -x"
 end
 
 # Specs
@@ -50,7 +73,7 @@ Spec::Rake::SpecTask.new(:spec) do |t|
   t.spec_files = Pathname.glob(ENV['FILES'] || 'spec/**/*_spec.rb')
 
   begin
-    t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+    t.rcov = RUN_RCOV
     t.rcov_opts << '--exclude' << 'spec'
     t.rcov_opts << '--text-summary'
     t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
@@ -84,4 +107,4 @@ namespace :ci do
 
 end
 
-task :ci => ["ci:spec"]
+task :ci => ["ci:spec"]

data/ext-java/src/main/java/do_mysql/MySqlDriverDefinition.java

@@ -9,4 +9,14 @@ public class MySqlDriverDefinition extends AbstractDriverDefinition {
         return true;
     }
 
+    //@Override
+    public String quoteString(String str) {
+        StringBuffer quotedValue = new StringBuffer(str.length() + 2);
+        quotedValue.append("\'");
+        quotedValue.append(str.replaceAll("'", "\\\\'"));
+        // TODO: handle backslashes
+        quotedValue.append("\'");
+        return quotedValue.toString();
+    }
+
 }

data/ext/{do_mysql_ext.c → do_mysql_ext/do_mysql_ext.c}

@@ -10,10 +10,10 @@
 
 #define RUBY_CLASS(name) rb_const_get(rb_cObject, rb_intern(name))
 #define RUBY_STRING(char_ptr) rb_str_new2(char_ptr)
-#define TAINTED_STRING(name) rb_tainted_str_new2(name)
+#define TAINTED_STRING(name, length) rb_tainted_str_new(name, length)
 #define DRIVER_CLASS(klass, parent) (rb_define_class_under(mDOMysql, klass, parent))
 #define CONST_GET(scope, constant) (rb_funcall(scope, ID_CONST_GET, 1, rb_str_new2(constant)))
-#define CHECK_AND_RAISE(mysql_result_value) if (0 != mysql_result_value) { raise_mysql_error(connection, db, mysql_result_value); }
+#define CHECK_AND_RAISE(mysql_result_value, str) if (0 != mysql_result_value) { raise_mysql_error(connection, db, mysql_result_value, str); }
 #define PUTS(string) rb_funcall(rb_mKernel, rb_intern("puts"), 1, RUBY_STRING(string))
 
 #ifndef RSTRING_PTR
@@ -38,7 +38,6 @@
 static ID ID_TO_I;
 static ID ID_TO_F;
 static ID ID_TO_S;
-static ID ID_PARSE;
 static ID ID_TO_TIME;
 static ID ID_NEW;
 static ID ID_NEW_RATIONAL;
@@ -66,7 +65,6 @@ static VALUE rb_cDateTime;
 static VALUE rb_cRational;
 #endif
 static VALUE rb_cBigDecimal;
-static VALUE rb_cCGI;
 
 // Classes that we'll build in Init
 static VALUE mDOMysql;
@@ -77,53 +75,59 @@ static VALUE cReader;
 static VALUE eMysqlError;
 
 // Figures out what we should cast a given mysql field type to
-static char * ruby_type_from_mysql_type(MYSQL_FIELD *field) {
+static VALUE infer_ruby_type(MYSQL_FIELD *field) {
 
-  char* ruby_type_name;
+  char* ruby_type;
 
   switch(field->type) {
     case MYSQL_TYPE_NULL: {
-      ruby_type_name = NULL;
+      ruby_type = NULL;
       break;
     }
     case MYSQL_TYPE_TINY: {
-      ruby_type_name = "TrueClass";
+      ruby_type = "TrueClass";
       break;
     }
+    case MYSQL_TYPE_BIT:
     case MYSQL_TYPE_SHORT:
     case MYSQL_TYPE_LONG:
     case MYSQL_TYPE_INT24:
     case MYSQL_TYPE_LONGLONG:
     case MYSQL_TYPE_YEAR: {
-      ruby_type_name = "Fixnum";
+      ruby_type = "Fixnum";
       break;
     }
     case MYSQL_TYPE_DECIMAL:
+    case MYSQL_TYPE_NEWDECIMAL: {
+      ruby_type = "BigDecimal";
+      break;
+    }
     case MYSQL_TYPE_FLOAT:
     case MYSQL_TYPE_DOUBLE: {
-      ruby_type_name = "BigDecimal";
+      ruby_type = "Float";
       break;
     }
     case MYSQL_TYPE_TIMESTAMP:
     case MYSQL_TYPE_DATETIME: {
-      ruby_type_name = "DateTime";
+      ruby_type = "DateTime";
       break;
     }
     case MYSQL_TYPE_TIME: {
-      ruby_type_name = "DateTime";
+      ruby_type = "DateTime";
       break;
     }
-    case MYSQL_TYPE_DATE: {
-      ruby_type_name = "Date";
+    case MYSQL_TYPE_DATE:
+    case MYSQL_TYPE_NEWDATE: {
+      ruby_type = "Date";
       break;
     }
     default: {
-      // printf("Falling to default: %s - %d\n", field->name, field->type);
-      ruby_type_name = "String";
+      ruby_type = "String";
+      break;
     }
   }
 
-  return ruby_type_name;
+  return rb_str_new2(ruby_type);
 }
 
 // Find the greatest common denominator and reduce the provided numerator and denominator.
@@ -157,6 +161,15 @@ static VALUE seconds_to_offset(long seconds_offset) {
   return rb_funcall(rb_cRational, rb_intern("new!"), 2, rb_ll2inum(num), rb_ll2inum(den));
 }
 
+static VALUE timezone_to_offset(int hour_offset, int minute_offset) {
+  do_int64 seconds = 0;
+
+  seconds += hour_offset * 3600;
+  seconds += minute_offset * 60;
+
+  return seconds_to_offset(seconds);
+}
+
 static VALUE parse_date(const char *date) {
   int year, month, day;
   int jd, ajd;
@@ -193,43 +206,78 @@ static VALUE parse_time(const char *date) {
   return rb_funcall(rb_cTime, rb_intern("local"), 7, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec), INT2NUM(usec));
 }
 
-static VALUE parse_date_time(const char *date_time) {
+static VALUE parse_date_time(const char *date) {
   VALUE ajd, offset;
 
-  int year, month, day, hour, min, sec;
+  int year, month, day, hour, min, sec, usec, hour_offset, minute_offset;
   int jd;
   do_int64 num, den;
 
+
+  long int gmt_offset;
+  int is_dst;
+
   time_t rawtime;
   struct tm * timeinfo;
 
-  // Mysql date format: 2008-05-03 14:43:00
-  sscanf(date_time, "%4d-%2d-%2d %2d:%2d:%2d", &year, &month, &day, &hour, &min, &sec);
+  int tokens_read, max_tokens;
 
-  jd = jd_from_date(year, month, day);
+  if ( strcmp(date, "") == 0 ) {
+    return Qnil;
+  }
 
-  // Generate ajd with fractional days for the time
-  // Extracted from Date#jd_to_ajd, Date#day_fraction_to_time, and Rational#+ and #-
-  num = ((hour) * 1440) + ((min) * 24); // (Hour * Minutes in a day) + (minutes * 24)
+  if (0 != strchr(date, '.')) {
+    // This is a datetime with sub-second precision
+    tokens_read = sscanf(date, "%4d-%2d-%2d%*c%2d:%2d:%2d.%d%3d:%2d", &year, &month, &day, &hour, &min, &sec, &usec, &hour_offset, &minute_offset);
+    max_tokens = 9;
+  } else {
+    // This is a datetime second precision
+    tokens_read = sscanf(date, "%4d-%2d-%2d%*c%2d:%2d:%2d%3d:%2d", &year, &month, &day, &hour, &min, &sec, &hour_offset, &minute_offset);
+    max_tokens = 8;
+  }
 
-  // Get localtime
-  time(&rawtime);
-  timeinfo = localtime(&rawtime);
+  if (max_tokens == tokens_read) {
+    // We read the Date, Time, and Timezone info
+    minute_offset *= hour_offset < 0 ? -1 : 1;
+  } else if ((max_tokens - 1) == tokens_read) {
+    // We read the Date and Time, but no Minute Offset
+    minute_offset = 0;
+  } else if (tokens_read == 3) {
+    return parse_date(date);
+  } else if (tokens_read >= (max_tokens - 3)) {
+    // We read the Date and Time, default to the current locale's offset
 
-  // TODO: Refactor the following few lines to do the calculation with the *seconds*
-  // value instead of having to do the hour/minute math
-  int hour_offset = abs(timeinfo->tm_gmtoff) / 3600;
-  int minute_offset = abs(timeinfo->tm_gmtoff) % 3600 / 60;
+    // Get localtime
+    time(&rawtime);
+    timeinfo = localtime(&rawtime);
+
+    is_dst = timeinfo->tm_isdst * 3600;
+
+    // Reset to GM Time
+    timeinfo = gmtime(&rawtime);
+
+    gmt_offset = mktime(timeinfo) - rawtime;
+
+    if ( is_dst > 0 )
+      gmt_offset -= is_dst;
+
+    hour_offset = -(gmt_offset / 3600);
+    minute_offset = -(gmt_offset % 3600 / 60);
 
-  // Modify the numerator so when we apply the timezone everything works out
-  if (timeinfo->tm_gmtoff < 0) {
-    // If the Timezone is behind UTC, we need to add the time offset
-    num += (hour_offset * 1440) + (minute_offset * 24);
   } else {
-    // If the Timezone is ahead of UTC, we need to subtract the time offset
-    num -= (hour_offset * 1440) + (minute_offset * 24);
+    // Something went terribly wrong
+    rb_raise(eMysqlError, "Couldn't parse date: %s", date);
   }
 
+  jd = jd_from_date(year, month, day);
+
+  // Generate ajd with fractional days for the time
+  // Extracted from Date#jd_to_ajd, Date#day_fraction_to_time, and Rational#+ and #-
+  num = (hour * 1440) + (min * 24);
+
+  // Modify the numerator so when we apply the timezone everything works out
+  num -= (hour_offset * 1440) + (minute_offset * 24);
+
   den = (24 * 1440);
   reduce(&num, &den);
 
@@ -239,33 +287,33 @@ static VALUE parse_date_time(const char *date_time) {
 
   num = (jd * den) + num;
 
-  num = num * 2 - den;
+  num = num * 2;
+  num = num - den;
   den = den * 2;
+
   reduce(&num, &den);
 
   ajd = rb_funcall(rb_cRational, rb_intern("new!"), 2, rb_ull2inum(num), rb_ull2inum(den));
-
-  // Calculate the offset using the seconds from GMT
-  offset = seconds_to_offset(timeinfo->tm_gmtoff);
+  offset = timezone_to_offset(hour_offset, minute_offset);
 
   return rb_funcall(rb_cDateTime, ID_NEW_DATE, 3, ajd, offset, INT2NUM(2299161));
 }
 
 // Convert C-string to a Ruby instance of Ruby type "type"
-static VALUE typecast(const char* value, char* type) {
+static VALUE typecast(const char* value, unsigned long length, char* type) {
   if (NULL == value)
     return Qnil;
 
   if ( strcmp(type, "Class") == 0) {
-    return rb_funcall(mDO, rb_intern("find_const"), 1, TAINTED_STRING(value));
+    return rb_funcall(mDO, rb_intern("find_const"), 1, TAINTED_STRING(value, length));
   } else if ( strcmp(type, "Integer") == 0 || strcmp(type, "Fixnum") == 0 || strcmp(type, "Bignum") == 0 ) {
     return rb_cstr2inum(value, 10);
   } else if (0 == strcmp("String", type)) {
-    return TAINTED_STRING(value);
+    return TAINTED_STRING(value, length);
   } else if (0 == strcmp("Float", type) ) {
     return rb_float_new(rb_cstr_to_dbl(value, Qfalse));
   } else if (0 == strcmp("BigDecimal", type) ) {
-    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING(value));
+    return rb_funcall(rb_cBigDecimal, ID_NEW, 1, TAINTED_STRING(value, length));
   } else if (0 == strcmp("TrueClass", type) || 0 == strcmp("FalseClass", type)) {
     return (0 == value || 0 == strcmp("0", value)) ? Qfalse : Qtrue;
   } else if (0 == strcmp("Date", type)) {
@@ -275,142 +323,124 @@ static VALUE typecast(const char* value, char* type) {
   } else if (0 == strcmp("Time", type)) {
     return parse_time(value);
   } else {
-    return TAINTED_STRING(value);
+    return TAINTED_STRING(value, length);
   }
 }
 
-static void data_objects_debug(VALUE string) {
+static void data_objects_debug(VALUE string, struct timeval* start) {
+  struct timeval stop;
+  char *message;
+
+  char *query = RSTRING_PTR(string);
+  int length  = RSTRING_LEN(string);
+  char total_time[32];
+  do_int64 duration = 0;
+
   VALUE logger = rb_funcall(mDOMysql, ID_LOGGER, 0);
   int log_level = NUM2INT(rb_funcall(logger, ID_LEVEL, 0));
 
   if (0 == log_level) {
-    rb_funcall(logger, ID_DEBUG, 1, string);
+    gettimeofday(&stop, NULL);
+
+    duration = (stop.tv_sec - start->tv_sec) * 1000000 + stop.tv_usec - start->tv_usec;
+    if(stop.tv_usec < start->tv_usec) {
+      duration += 1000000;
+    }
+
+    snprintf(total_time, 32, "%.6f", duration / 1000000.0);
+    message = (char *)calloc(length + strlen(total_time) + 4, sizeof(char));
+    snprintf(message, length + strlen(total_time) + 4, "(%s) %s", total_time, query);
+    rb_funcall(logger, ID_DEBUG, 1, rb_str_new(message, length + strlen(total_time) + 3));
   }
 }
+static void raise_mysql_error(VALUE connection, MYSQL *db, int mysql_error_code, char* str) {
+  char *mysql_error_message = (char *)mysql_error(db);
 
-static void flush_pool(VALUE connection) {
-  data_objects_debug(rb_funcall(connection, rb_intern("inspect"), 0));
-  if ( Qnil != connection ) {
-    VALUE pool = rb_iv_get(connection, "@__pool");
-    rb_funcall(pool, rb_intern("flush!"), 0);
-    rb_funcall(pool, rb_intern("delete"), 1, connection);
-    rb_funcall(connection, rb_intern("dispose"), 0);
+  if(mysql_error_code == 1) {
+    mysql_error_code = mysql_errno(db);
+  }
+  if(str) {
+    rb_raise(eMysqlError, "(mysql_errno=%04d, sql_state=%s) %s\nQuery: %s", mysql_error_code, mysql_sqlstate(db), mysql_error_message, str);
+  } else {
+    rb_raise(eMysqlError, "(mysql_errno=%04d, sql_state=%s) %s", mysql_error_code, mysql_sqlstate(db), mysql_error_message);
   }
 }
 
-// We can add custom information to error messages using this function
-// if we think it matters
-static void raise_mysql_error(VALUE connection, MYSQL *db, int mysql_error_code) {
-  char *mysql_error_message = (char *)mysql_error(db);
-  int length = strlen(mysql_error_message) + 25; // length of " (mysql_error_code=0000)"
-  char *error_message = (char *)calloc(length, sizeof(char));
-
-  sprintf(error_message, "%s (mysql_error_code=%04d)", mysql_error_message, mysql_error_code);
-
-  data_objects_debug(rb_str_new2(error_message));
-
-  switch(mysql_error_code) {
-    case CR_UNKNOWN_ERROR:
-    case CR_SOCKET_CREATE_ERROR:
-    case CR_CONNECTION_ERROR:
-    case CR_CONN_HOST_ERROR:
-    case CR_IPSOCK_ERROR:
-    case CR_UNKNOWN_HOST:
-    case CR_SERVER_GONE_ERROR:
-    case CR_VERSION_ERROR:
-    case CR_OUT_OF_MEMORY:
-    case CR_WRONG_HOST_INFO:
-    case CR_LOCALHOST_CONNECTION:
-    case CR_TCP_CONNECTION:
-    case CR_SERVER_HANDSHAKE_ERR:
-    case CR_SERVER_LOST:
-    case CR_COMMANDS_OUT_OF_SYNC:
-    case CR_NAMEDPIPE_CONNECTION:
-    case CR_NAMEDPIPEWAIT_ERROR:
-    case CR_NAMEDPIPEOPEN_ERROR:
-    case CR_NAMEDPIPESETSTATE_ERROR:
-    case CR_CANT_READ_CHARSET:
-    case CR_NET_PACKET_TOO_LARGE:
-    case CR_EMBEDDED_CONNECTION:
-    case CR_PROBE_SLAVE_STATUS:
-    case CR_PROBE_SLAVE_HOSTS:
-    case CR_PROBE_SLAVE_CONNECT:
-    case CR_PROBE_MASTER_CONNECT:
-    case CR_SSL_CONNECTION_ERROR:
-    case CR_MALFORMED_PACKET:
-    case CR_WRONG_LICENSE:
-    case CR_NULL_POINTER:
-    case CR_NO_PREPARE_STMT:
-    case CR_PARAMS_NOT_BOUND:
-    case CR_DATA_TRUNCATED:
-    case CR_NO_PARAMETERS_EXISTS:
-    case CR_INVALID_PARAMETER_NO:
-    case CR_INVALID_BUFFER_USE:
-    case CR_UNSUPPORTED_PARAM_TYPE:
-    case CR_SHARED_MEMORY_CONNECTION:
-    case CR_SHARED_MEMORY_CONNECT_REQUEST_ERROR:
-    case CR_SHARED_MEMORY_CONNECT_ANSWER_ERROR:
-    case CR_SHARED_MEMORY_CONNECT_FILE_MAP_ERROR:
-    case CR_SHARED_MEMORY_CONNECT_MAP_ERROR:
-    case CR_SHARED_MEMORY_FILE_MAP_ERROR:
-    case CR_SHARED_MEMORY_MAP_ERROR:
-    case CR_SHARED_MEMORY_EVENT_ERROR:
-    case CR_SHARED_MEMORY_CONNECT_ABANDONED_ERROR:
-    case CR_SHARED_MEMORY_CONNECT_SET_ERROR:
-    case CR_CONN_UNKNOW_PROTOCOL:
-    case CR_INVALID_CONN_HANDLE:
-    case CR_SECURE_AUTH:
-    case CR_FETCH_CANCELED:
-    case CR_NO_DATA:
-    case CR_NO_STMT_METADATA:
-#if MYSQL_VERSION_ID >= 50000
-    case CR_NO_RESULT_SET:
-    case CR_NOT_IMPLEMENTED:
-#endif
-    {
-      break;
-    }
-    default: {
-      // Hmmm
-      break;
-    }
+static char * get_uri_option(VALUE query_hash, char * key) {
+  VALUE query_value;
+  char * value = NULL;
+
+  if(!rb_obj_is_kind_of(query_hash, rb_cHash)) { return NULL; }
+
+  query_value = rb_hash_aref(query_hash, RUBY_STRING(key));
+
+  if (Qnil != query_value) {
+    value = StringValuePtr(query_value);
   }
 
-  flush_pool(connection);
-  rb_raise(eMysqlError, error_message);
+  return value;
 }
 
-// Pull an option out of a querystring-formmated option list using CGI::parse
-static char * get_uri_option(VALUE querystring, char * key) {
-  VALUE options_hash, option_value;
+static MYSQL_RES* cCommand_execute_async(VALUE self, MYSQL* db, VALUE query) {
+  int socket_fd;
+  int retval;
+  fd_set rset;
+  struct timeval start;
+  char* str = RSTRING_PTR(query);
+  int len   = RSTRING_LEN(query);
+
+  VALUE connection = rb_iv_get(self, "@connection");
+
+  retval = mysql_ping(db);
+  if(retval == CR_SERVER_GONE_ERROR) {
+    CHECK_AND_RAISE(retval, "Mysql server has gone away. \
+                             Please report this issue to the Datamapper project. \
+                             Specify your at least your MySQL version when filing a ticket");
+  }
+  retval = mysql_send_query(db, str, len);
 
-  char * value = NULL;
+  CHECK_AND_RAISE(retval, str);
+  gettimeofday(&start, NULL);
 
-  // Ensure that we're dealing with a string
-  querystring = rb_funcall(querystring, ID_TO_S, 0);
+  socket_fd = db->net.fd;
+
+  for(;;) {
+    FD_ZERO(&rset);
+    FD_SET(socket_fd, &rset);
+
+    retval = rb_thread_select(socket_fd + 1, &rset, NULL, NULL, NULL);
 
-  options_hash = rb_funcall(rb_cCGI, ID_PARSE, 1, querystring);
+    if (retval < 0) {
+        rb_sys_fail(0);
+    }
 
-  // TODO: rb_hash_aref always returns an array?
-  option_value = rb_ary_entry(rb_hash_aref(options_hash, RUBY_STRING(key)), 0);
+    if (retval == 0) {
+        continue;
+    }
 
-  if (Qnil != option_value) {
-    value = StringValuePtr(option_value);
+    if (db->status == MYSQL_STATUS_READY) {
+      break;
+    }
   }
 
-  return value;
+  retval = mysql_read_query_result(db);
+  CHECK_AND_RAISE(retval, str);
+
+  data_objects_debug(query, &start);
+
+  return mysql_store_result(db);
 }
 
 static VALUE cConnection_initialize(VALUE self, VALUE uri) {
-  VALUE r_host, r_user, r_password, r_path, r_options, r_port;
+  VALUE r_host, r_user, r_password, r_path, r_query, r_port;
 
   char *host = "localhost", *user = "root", *password = NULL, *path;
   char *database = "", *socket = NULL;
-  char *charset = NULL;
+  char *encoding = NULL;
 
   int port = 3306;
   unsigned long client_flags = 0;
-  int charset_error;
+  int encoding_error;
 
   MYSQL *db = 0, *result;
   db = (MYSQL *)mysql_init(NULL);
@@ -432,7 +462,6 @@ static VALUE cConnection_initialize(VALUE self, VALUE uri) {
     password = StringValuePtr(r_password);
   }
 
-
   r_path = rb_funcall(uri, rb_intern("path"), 0);
   path = StringValuePtr(r_path);
   if (Qnil != r_path) {
@@ -444,11 +473,11 @@ static VALUE cConnection_initialize(VALUE self, VALUE uri) {
   }
 
   // Pull the querystring off the URI
-  r_options = rb_funcall(uri, rb_intern("query"), 0);
+  r_query = rb_funcall(uri, rb_intern("query"), 0);
 
   // Check to see if we're on the db machine.  If so, try to use the socket
   if (0 == strcasecmp(host, "localhost")) {
-    socket = get_uri_option(r_options, "socket");
+    socket = get_uri_option(r_query, "socket");
     if (NULL != socket) {
       rb_iv_set(self, "@using_socket", Qtrue);
     }
@@ -459,7 +488,9 @@ static VALUE cConnection_initialize(VALUE self, VALUE uri) {
     port = NUM2INT(r_port);
   }
 
-  charset = get_uri_option(r_options, "charset");
+  encoding = get_uri_option(r_query, "encoding");
+  if (!encoding) { encoding = get_uri_option(r_query, "charset"); }
+  if (!encoding) { encoding = "utf8"; }
 
   // If ssl? {
   //   mysql_ssl_set(db, key, cert, ca, capath, cipher)
@@ -480,20 +511,19 @@ static VALUE cConnection_initialize(VALUE self, VALUE uri) {
   );
 
   if (NULL == result) {
-    raise_mysql_error(Qnil, db, -1);
-  }
-
-  if (NULL == charset) {
-    charset = (char*)calloc(5, sizeof(char));
-    strcpy(charset, "utf8");
+    raise_mysql_error(Qnil, db, -1, NULL);
   }
 
   // Set the connections character set
-  charset_error = mysql_set_character_set(db, charset);
-  if (0 != charset_error) {
-    raise_mysql_error(Qnil, db, charset_error);
+  encoding_error = mysql_set_character_set(db, encoding);
+  if (0 != encoding_error) {
+    raise_mysql_error(Qnil, db, encoding_error, NULL);
   }
 
+  // Disable sql_auto_is_null
+  cCommand_execute_async(self, db, rb_str_new2("SET sql_auto_is_null = 0"));
+  cCommand_execute_async(self, db, rb_str_new2("SET SESSION sql_mode = 'ANSI,NO_AUTO_VALUE_ON_ZERO,NO_DIR_IN_CREATE,NO_ENGINE_SUBSTITUTION,NO_UNSIGNED_SUBTRACTION,ONLY_FULL_GROUP_BY,TRADITIONAL'"));
+
   rb_iv_set(self, "@uri", uri);
   rb_iv_set(self, "@connection", Data_Wrap_Struct(rb_cObject, 0, 0, db));
 
@@ -504,16 +534,16 @@ static VALUE cConnection_character_set(VALUE self) {
   VALUE connection_container = rb_iv_get(self, "@connection");
   MYSQL *db;
 
-  const char *charset;
+  const char *encoding;
 
   if (Qnil == connection_container)
     return Qfalse;
 
   db = DATA_PTR(connection_container);
 
-  charset = mysql_character_set_name(db);
+  encoding = mysql_character_set_name(db);
 
-  return RUBY_STRING(charset);
+  return RUBY_STRING(encoding);
 }
 
 static VALUE cConnection_is_using_socket(VALUE self) {
@@ -573,7 +603,8 @@ VALUE cCommand_quote_date(VALUE self, VALUE value) {
 
 static VALUE cCommand_quote_string(VALUE self, VALUE string) {
   MYSQL *db = DATA_PTR(rb_iv_get(rb_iv_get(self, "@connection"), "@connection"));
-  const char *source = StringValuePtr(string);
+  const char *source = RSTRING_PTR(string);
+  int source_len     = RSTRING_LEN(string);
   char *escaped;
   VALUE result;
 
@@ -582,10 +613,10 @@ static VALUE cCommand_quote_string(VALUE self, VALUE string) {
   // Allocate space for the escaped version of 'string'.  Use + 3 allocate space for null term.
   // and the leading and trailing single-quotes.
   // Thanks to http://www.browardphp.com/mysql_manual_en/manual_MySQL_APIs.html#mysql_real_escape_string
-  escaped = (char *)calloc(strlen(source) * 3 + 3, sizeof(char));
+  escaped = (char *)calloc(source_len * 2 + 3, sizeof(char));
 
-  // Escape 'source' using the current charset in use on the conection 'db'
-  quoted_length = mysql_real_escape_string(db, escaped + 1, source, strlen(source));
+  // Escape 'source' using the current encoding in use on the conection 'db'
+  quoted_length = mysql_real_escape_string(db, escaped + 1, source, source_len);
 
   // Wrap the escaped string in single-quotes, this is DO's convention
   escaped[0] = escaped[quoted_length + 1] = '\'';
@@ -607,46 +638,6 @@ static VALUE build_query_from_args(VALUE klass, int count, VALUE *args) {
   return query;
 }
 
-static MYSQL_RES* cCommand_execute_async(VALUE self, MYSQL* db, VALUE query) {
-  int socket_fd;
-  int retval;
-  fd_set rset;
-  char* str = RSTRING_PTR(query);
-  int len   = RSTRING_LEN(query);
-
-  VALUE connection = rb_iv_get(self, "@connection");
-
-  retval = mysql_send_query(db, str, len);
-  data_objects_debug(query);
-  CHECK_AND_RAISE(retval);
-
-  socket_fd = db->net.fd;
-
-  for(;;) {
-    FD_ZERO(&rset);
-    FD_SET(socket_fd, &rset);
-
-    retval = rb_thread_select(socket_fd + 1, &rset, NULL, NULL, NULL);
-
-    if (retval < 0) {
-        rb_sys_fail(0);
-    }
-
-    if (retval == 0) {
-        continue;
-    }
-
-    if (db->status == MYSQL_STATUS_READY) {
-      break;
-    }
-  }
-
-  retval = mysql_read_query_result(db);
-  CHECK_AND_RAISE(retval);
-
-  return mysql_store_result(db);
-}
-
 static VALUE cCommand_execute_non_query(int argc, VALUE *argv, VALUE self) {
   VALUE query;
 
@@ -676,14 +667,15 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
   VALUE query, reader;
   VALUE field_names, field_types;
 
-  int field_count;
+  unsigned int field_count;
   int i;
 
   char guess_default_field_types = 0;
   VALUE connection = rb_iv_get(self, "@connection");
   VALUE mysql_connection = rb_iv_get(connection, "@connection");
-  if (Qnil == mysql_connection)
+  if (Qnil == mysql_connection) {
     rb_raise(eMysqlError, "This connection has already been closed.");
+  }
 
   MYSQL *db = DATA_PTR(mysql_connection);
 
@@ -698,7 +690,7 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
     return Qnil;
   }
 
-  field_count = (int)mysql_field_count(db);
+  field_count = mysql_field_count(db);
 
   reader = rb_funcall(cReader, ID_NEW, 0);
   rb_iv_set(reader, "@reader", Data_Wrap_Struct(rb_cObject, 0, 0, response));
@@ -715,7 +707,6 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
     // Whoops...  wrong number of types passed to set_types.  Close the reader and raise
     // and error
     rb_funcall(reader, rb_intern("close"), 0);
-    flush_pool(connection);
     rb_raise(eMysqlError, "Field-count mismatch. Expected %ld fields, but the query yielded %d", RARRAY_LEN(field_types), field_count);
   }
 
@@ -724,8 +715,7 @@ static VALUE cCommand_execute_reader(int argc, VALUE *argv, VALUE self) {
     rb_ary_push(field_names, RUBY_STRING(field->name));
 
     if (1 == guess_default_field_types) {
-      VALUE field_ruby_type_name = RUBY_STRING(ruby_type_from_mysql_type(field));
-      rb_ary_push(field_types, field_ruby_type_name);
+      rb_ary_push(field_types, infer_ruby_type(field));
     }
   }
 
@@ -770,6 +760,7 @@ static VALUE cReader_next(VALUE self) {
 
   MYSQL_RES *reader;
   MYSQL_ROW result;
+  unsigned long *lengths;
 
   int i;
   char *field_type;
@@ -783,6 +774,7 @@ static VALUE cReader_next(VALUE self) {
   ruby_field_type_strings = rb_iv_get(self, "@field_types");
   row = rb_ary_new();
   result = (MYSQL_ROW)mysql_fetch_row(reader);
+  lengths = mysql_fetch_lengths(reader);
 
   rb_iv_set(self, "@state", result ? Qtrue : Qfalse);
 
@@ -792,7 +784,7 @@ static VALUE cReader_next(VALUE self) {
   for (i = 0; i < reader->field_count; i++) {
     // The field_type data could be cached in a c-array
     field_type = RSTRING_PTR(rb_ary_entry(ruby_field_type_strings, i));
-    rb_ary_push(row, typecast(result[i], field_type));
+    rb_ary_push(row, typecast(result[i], lengths[i], field_type));
   }
 
   rb_iv_set(self, "@values", row);
@@ -815,17 +807,14 @@ static VALUE cReader_fields(VALUE self) {
 }
 
 void Init_do_mysql_ext() {
-  rb_require("rubygems");
   rb_require("bigdecimal");
   rb_require("date");
-  rb_require("cgi");
 
   rb_funcall(rb_mKernel, rb_intern("require"), 1, RUBY_STRING("data_objects"));
 
   ID_TO_I = rb_intern("to_i");
   ID_TO_F = rb_intern("to_f");
   ID_TO_S = rb_intern("to_s");
-  ID_PARSE = rb_intern("parse");
   ID_TO_TIME = rb_intern("to_time");
   ID_NEW = rb_intern("new");
   ID_NEW_RATIONAL = rb_intern("new!");
@@ -847,7 +836,6 @@ void Init_do_mysql_ext() {
   rb_cDateTime = RUBY_CLASS("DateTime");
   rb_cRational = RUBY_CLASS("Rational");
   rb_cBigDecimal = RUBY_CLASS("BigDecimal");
-  rb_cCGI = RUBY_CLASS("CGI");
 
   // Get references to the DataObjects module and its classes
   mDO = CONST_GET(rb_mKernel, "DataObjects");

data/lib/do_mysql.rb

@@ -1,15 +1,20 @@
 require 'rubygems'
 require 'data_objects'
-require 'do_mysql_ext' # the C/Java extension for this DO driver
-require 'do_mysql' / 'transaction'
-
 if RUBY_PLATFORM =~ /java/
-  require 'do_jdbc/mysql'   # the JDBC driver, packaged as a gem
+  require 'do_jdbc'
+  require 'java'
+  gem 'jdbc-mysql'
+  require 'jdbc/mysql' # the JDBC driver, packaged as a gem
+end
 
-  # Another way of loading the JDBC Class. This seems to be more relaible
+require File.expand_path(File.join(File.dirname(__FILE__), 'do_mysql_ext'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'do_mysql', 'version'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'do_mysql', 'transaction'))
+
+if RUBY_PLATFORM =~ /java/
+  # Another way of loading the JDBC Class. This seems to be more reliable
   # than Class.forName() within the data_objects.Connection Java class,
   # which is currently not working as expected.
-  require 'java'
   import 'com.mysql.jdbc.Driver'
 
   module DataObjects
@@ -18,6 +23,17 @@ if RUBY_PLATFORM =~ /java/
         def self.pool_size
           20
         end
+
+        def using_socket?
+          @using_socket
+        end
+        
+        def character_set
+          # JDBC API does not provide an easy way to get the current character set
+          # For now, we code the character_set used as utf8
+          "utf8"
+        end
+
       end
     end
   end

data/lib/do_mysql/version.rb

@@ -1,5 +1,5 @@
 module DataObjects
   module Mysql
-    VERSION = "0.9.9"
+    VERSION = "0.9.10"
   end
 end

data/spec/integration/do_mysql_spec.rb

@@ -20,19 +20,18 @@ describe DataObjects::Mysql do
   end
 
   it "should connect successfully via TCP" do
-    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
-    connection = DataObjects::Connection.new("mysql://root@127.0.0.1:3306/do_mysql_test")
+    connection = DataObjects::Connection.new("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.host}:#{MYSQL.port}/#{MYSQL.database}")
     connection.should_not be_using_socket
     connection.close
   end
 
-  it "should be able to send querues asynchronuously in parallel" do
+  it "should be able to send queries asynchronously in parallel" do
     threads = []
 
     start = Time.now
     4.times do |i|
       threads << Thread.new do
-        connection = DataObjects::Connection.new("mysql://root@127.0.0.1:3306/do_mysql_test")
+        connection = DataObjects::Connection.new("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.host}:#{MYSQL.port}/#{MYSQL.database}")
         command = connection.create_command("SELECT sleep(1)")
         result = command.execute_non_query
       end
@@ -49,54 +48,60 @@ describe DataObjects::Mysql do
 #  It's not really a requirement, since all architectures that support MySQL also supports TCP connectsion, ne?
 #
 #  it "should connect successfully via the socket file" do
-#    @connection = DataObjects::Mysql::Connection.new("mysql://root@localhost:3306/do_mysql_test/?socket=#{SOCKET_PATH}")
+#    @connection = DataObjects::Mysql::Connection.new("mysql://#{MYSQL.user}@#{MYSQL.hostname}:#{MYSQL.port}/#{MYSQL.database}/?socket=#{SOCKET_PATH}")
 #    @connection.should be_using_socket
 #  end
 
   it "should return the current character set" do
-    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
-    connection = DataObjects::Connection.new("mysql://root@localhost:3306/do_mysql_test")
+    connection = DataObjects::Connection.new("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.hostname}:#{MYSQL.port}/#{MYSQL.database}")
     connection.character_set.should == "utf8"
     connection.close
   end
 
   it "should support changing the character set" do
-    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
-    connection = DataObjects::Connection.new("mysql://root@localhost:3306/do_mysql_test/?charset=latin1")
+    pending "JDBC API does not provide an easy way to get the current character set" if JRUBY
+    # current character set can be retrieved with the following query:
+    # "SHOW VARIABLES LIKE character_set_database"
+
+    connection = DataObjects::Connection.new("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.hostname}:#{MYSQL.port}/#{MYSQL.database}?charset=latin1")
+                 # N.B. query parameter after forward slash causes problems with JDBC
     connection.character_set.should == "latin1"
     connection.close
 
-    connection = DataObjects::Connection.new("mysql://root@localhost:3306/do_mysql_test/?charset=utf8")
+    connection = DataObjects::Connection.new("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.hostname}:#{MYSQL.port}/#{MYSQL.database}?charset=utf8")
     connection.character_set.should == "utf8"
     connection.close
   end
 
   it "should raise an error when opened with an invalid server uri" do
-    pending "Problems parsing regular connection URIs vs. JDBC URLs" if JRUBY
     def connecting_with(uri)
       lambda { DataObjects::Connection.new(uri) }
     end
 
-    # Missing database name
-    connecting_with("mysql://root@localhost:3306/").should raise_error(MysqlError)
+    unless JRUBY  ## FIXME in JRuby
+      # Missing database name
+      connecting_with("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.hostname}:#{MYSQL.port}/").should raise_error(MysqlError)
+    end
 
     # Wrong port
-    connecting_with("mysql://root@localhost:666/").should raise_error(MysqlError)
+    connecting_with("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.hostname}:666/").should raise_error(MysqlError)
 
-    # Bad Username
-    connecting_with("mysql://baduser@localhost:3306/").should raise_error(MysqlError)
+    unless JRUBY  ## FIXME in JRuby
+      # Bad Username
+      connecting_with("mysql://baduser@#{MYSQL.hostname}:#{MYSQL.port}/").should raise_error(MysqlError)
+    end
 
     # Bad Password
-    connecting_with("mysql://root:wrongpassword@localhost:3306/").should raise_error(MysqlError)
+    connecting_with("mysql://#{MYSQL.user}:wrongpassword@#{MYSQL.hostname}:#{MYSQL.port}/").should raise_error(MysqlError)
 
     # Bad Database Name
-    connecting_with("mysql://root@localhost:3306/bad_database").should raise_error(MysqlError)
+    connecting_with("mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.hostname}:#{MYSQL.port}/bad_database").should raise_error(MysqlError)
 
     #
     # Again, should socket even be speced if we don't support it across all platforms?
     #
     # Invalid Socket Path
-    #connecting_with("mysql://root@localhost:3306/do_mysql_test/?socket=/invalid/path/mysql.sock").should raise_error(MysqlError)
+    #connecting_with("mysql://#{MYSQL.user}@#{MYSQL.hostname}:#{MYSQL.port}/MYSQL.database/?socket=/invalid/path/mysql.sock").should raise_error(MysqlError)
   end
 end
 
@@ -119,32 +124,14 @@ describe DataObjects::Mysql::Connection do
     lambda { @connection.create_command("SELECT * FROM non_existant_table").execute_reader }.should raise_error(MysqlError)
   end
 
-  it "should close the connection when executing a bad query" do
-    lambda { @connection.create_command("INSERT INTO non_exista (tester) VALUES (1)").execute_non_query }.should raise_error(MysqlError)
-    @connection.instance_variable_get(:@connection).should == nil
-  end
-
-  it "should flush the pool when executing a bad query" do
-    pool = @connection.instance_variable_get(:@__pool)
-    lambda { @connection.create_command("INSERT INTO non_exista (tester) VALUES (1)").execute_non_query }.should raise_error(MysqlError)
-    Extlib::Pooling.pools.detect { |p| p == pool }.instance_variable_get(:@available).size.should == 0
-  end
-
-  it "should delete itself from the pool" do
-    pool = @connection.instance_variable_get(:@__pool)
-    count = pool.size
-    lambda { @connection.create_command("INSERT INTO non_exista (tester) VALUES (1)").execute_non_query }.should raise_error(MysqlError)
-    Extlib::Pooling.pools.detect { |p| p == pool }.size.should == count-1
-  end
-
-  it "should not raise an error error executing a non query on a closed connection" do
+  it "should not raise a connection closed error after an incorrect query" do
     lambda { @connection.create_command("INSERT INTO non_existant_table (tester) VALUES (1)").execute_non_query }.should raise_error(MysqlError)
-    lambda { @connection.create_command("INSERT INTO non_existant_table (tester) VALUES (1)").execute_non_query }.should raise_error(MysqlError, "This connection has already been closed.")
+    lambda { @connection.create_command("INSERT INTO non_existant_table (tester) VALUES (1)").execute_non_query }.should_not raise_error(MysqlError, "This connection has already been closed.")
   end
 
-  it "should not raise an error executing a reader on a closed connection" do
+  it "should not raise a connection closed error after an incorrect reader" do
     lambda { @connection.create_command("SELECT * FROM non_existant_table").execute_reader }.should raise_error(MysqlError)
-    lambda { @connection.create_command("SELECT * FROM non_existant_table").execute_reader }.should raise_error(MysqlError, "This connection has already been closed.")
+    lambda { @connection.create_command("SELECT * FROM non_existant_table").execute_reader }.should_not raise_error(MysqlError, "This connection has already been closed.")
   end
 
 end
@@ -176,6 +163,7 @@ describe DataObjects::Mysql::Reader do
   end
 
   it "should raise an exception if .values is called after reading all available rows" do
+
     select("SELECT * FROM widgets LIMIT 2") do |reader|
       # select already calls next once for us
       reader.next!
@@ -190,7 +178,8 @@ describe DataObjects::Mysql::Reader do
       insert("INSERT INTO users (name) VALUES ('Slappy Wilson')"),
       insert("INSERT INTO users (name) VALUES ('Jumpy Jones')")
     ]
-
+                                            # do_jdbc rewrites "?" as "(?,?)"
+                                            # to correspond to the JDBC API
     select("SELECT * FROM users WHERE id IN ?", nil, ids) do |reader|
       # select already calls next once for us
       reader.next!.should == true
@@ -224,11 +213,21 @@ describe DataObjects::Mysql::Reader do
   describe "Date, Time, and DateTime" do
 
     it "should return nil when the time is 0" do
-      id = insert("INSERT INTO users (name, fired_at) VALUES ('James', 0);")
-      select("SELECT fired_at FROM users WHERE id = ?", [Time], id) do |reader|
-        reader.values.last.should be_nil
+
+      # skip the test if the strict dates/times setting is turned on
+      strict_time = select("SHOW VARIABLES LIKE 'sql_mode'") do |reader|
+        reader.values.last.split(',').any? do |mode|
+          %w[ NO_ZERO_IN_DATE NO_ZERO_DATE ].include?(mode.strip.upcase)
+        end
+      end
+
+      unless strict_time
+        id = insert("INSERT INTO users (name, fired_at) VALUES ('James', 0);")
+        select("SELECT fired_at FROM users WHERE id = ?", [Time], id) do |reader|
+          reader.values.last.should be_nil
+        end
+        exec("DELETE FROM users WHERE id = ?", id)
       end
-      exec("DELETE FROM users WHERE id = ?", id)
     end
 
     it "should return DateTimes using the current locale's Time Zone" do

data/spec/integration/logging_spec.rb

@@ -4,11 +4,7 @@ require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
 describe DataObjects::Mysql::Command do
 
   before(:each) do
-    @connection = if JRUBY
-      DataObjects::Connection.new(DO_MYSQL_SPEC_JDBC_URI)
-    else
-      DataObjects::Connection.new(DO_MYSQL_SPEC_URI)
-    end
+    @connection = DataObjects::Connection.new(DO_MYSQL_SPEC_URI)
   end
 
   after(:each) do
@@ -21,7 +17,7 @@ describe DataObjects::Mysql::Command do
       command = @connection.create_command("SELECT * FROM widgets WHERE name = ?")
       @mock_logger = mock('MockLogger', :level => 0)
       DataObjects::Mysql.should_receive(:logger).and_return(@mock_logger)
-      @mock_logger.should_receive(:debug).with("SELECT * FROM widgets WHERE name = 'Scott'")
+      @mock_logger.should_receive(:debug).with(/\([\d.]+\) SELECT \* FROM widgets WHERE name = 'Scott'/)
 
       command.execute_reader('Scott').close # Readers must be closed!
     end
@@ -40,7 +36,7 @@ describe DataObjects::Mysql::Command do
       command = @connection.create_command("INSERT INTO invoices (invoice_number) VALUES (?)")
       @mock_logger = mock('MockLogger', :level => 0)
       DataObjects::Mysql.should_receive(:logger).and_return(@mock_logger)
-      @mock_logger.should_receive(:debug).with("INSERT INTO invoices (invoice_number) VALUES (1234)")
+      @mock_logger.should_receive(:debug).with(/\([\d.]+\) INSERT INTO invoices \(invoice_number\) VALUES \(1234\)/)
       command.execute_non_query(1234)
     end
 

data/spec/integration/quoting_spec.rb

@@ -1,41 +1,45 @@
 require 'pathname'
 require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
-require 'date'
 
-describe DataObjects::Mysql::Command, "Quoting" do
-  include MysqlSpecHelpers
+unless JRUBY
+  require 'date'
+
+  describe DataObjects::Mysql::Command, "Quoting" do
+    include MysqlSpecHelpers
+
+    before :each do
+      setup_test_environment
+    end
+
+    after :each do
+      teardown_test_environment
+    end
+
+    it "should escape strings properly" do
+      command = @connection.create_command("SELECT * FROM widgets WHERE name = ?")
+      command.quote_string("Willy O'Hare & Johnny O'Toole").should == "'Willy O\\'Hare & Johnny O\\'Toole'".dup
+      command.quote_string("The\\Backslasher\\Rises\\Again").should == "'The\\\\Backslasher\\\\Rises\\\\Again'"
+      command.quote_string("Scott \"The Rage\" Bauer").should == "'Scott \\\"The Rage\\\" Bauer'"
+    end
+
+    it "should quote DateTime instances properly" do
+      command = @connection.create_command("SELECT * FROM widgets WHERE release_datetime >= ?")
+      dt = DateTime.now
+      command.quote_datetime(dt).should == "'#{dt.strftime('%Y-%m-%d %H:%M:%S')}'"
+    end
+
+    it "should quote Time instances properly" do
+      command = @connection.create_command("SELECT * FROM widgets WHERE release_timestamp >= ?")
+      dt = Time.now
+      command.quote_time(dt).should == "'#{dt.strftime('%Y-%m-%d %H:%M:%S')}'"
+    end
+
+    it "should quote Date instances properly" do
+      command = @connection.create_command("SELECT * FROM widgets WHERE release_date >= ?")
+      dt = Date.today
+      command.quote_date(dt).should == "'#{dt.strftime('%Y-%m-%d')}'"
+    end
 
-  before :each do
-    setup_test_environment
-  end
-
-  after :each do
-    teardown_test_environment
-  end
-
-  it "should escape strings properly" do
-    command = @connection.create_command("SELECT * FROM widgets WHERE name = ?")
-    command.quote_string("Willy O'Hare & Johnny O'Toole").should == "'Willy O\\'Hare & Johnny O\\'Toole'".dup
-    command.quote_string("The\\Backslasher\\Rises\\Again").should == "'The\\\\Backslasher\\\\Rises\\\\Again'"
-    command.quote_string("Scott \"The Rage\" Bauer").should == "'Scott \\\"The Rage\\\" Bauer'"
-  end
-
-  it "should quote DateTime instances properly" do
-    command = @connection.create_command("SELECT * FROM widgets WHERE release_datetime >= ?")
-    dt = DateTime.now
-    command.quote_datetime(dt).should == "'#{dt.strftime('%Y-%m-%d %H:%M:%S')}'"
-  end
-
-  it "should quote Time instances properly" do
-    command = @connection.create_command("SELECT * FROM widgets WHERE release_timestamp >= ?")
-    dt = Time.now
-    command.quote_time(dt).should == "'#{dt.strftime('%Y-%m-%d %H:%M:%S')}'"
-  end
-
-  it "should quote Date instances properly" do
-    command = @connection.create_command("SELECT * FROM widgets WHERE release_date >= ?")
-    dt = Date.today
-    command.quote_date(dt).should == "'#{dt.strftime('%Y-%m-%d')}'"
   end
 
 end

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ gem 'rspec', '>=1.1.3'
 require 'spec'
 
 require 'date'
+require 'ostruct'
 require 'pathname'
 require 'fileutils'
 
@@ -31,9 +32,17 @@ DataObjects::Mysql.logger = DataObjects::Logger.new(log_path, 0)
 
 at_exit { DataObjects.logger.flush }
 
-# use different, JDBC-style URLs for JRuby, for the time-being
-DO_MYSQL_SPEC_URI      = Addressable::URI::parse(ENV["DO_MYSQL_SPEC_URI"]      || "mysql://root@127.0.0.1:3306/do_mysql_test")
-DO_MYSQL_SPEC_JDBC_URI = Addressable::URI::parse(ENV["DO_MYSQL_SPEC_JDBC_URI"] || "jdbc:mysql://localhost:3306/do_mysql_test?user=root")
+MYSQL = OpenStruct.new
+MYSQL.user = ENV['DO_MYSQL_USER'] || 'root'
+MYSQL.pass = ENV['DO_MYSQL_PASS'] || ''
+MYSQL.host = ENV['DO_MYSQL_HOST'] || '127.0.0.1'
+MYSQL.hostname = ENV['DO_MYSQL_HOSTNAME'] || 'localhost'
+MYSQL.port     = ENV['DO_MYSQL_PORT'] || '3306'
+MYSQL.database = ENV['DO_MYSQL_DATABASE'] || 'do_mysql_test'
+MYSQL.socket   = ENV['DO_MYSQL_SOCKET'] || '/tmp/mysql.sock'
+
+DO_MYSQL_SPEC_URI = Addressable::URI::parse(ENV["DO_MYSQL_SPEC_URI"] ||
+                    "mysql://#{MYSQL.user}:#{MYSQL.pass}@#{MYSQL.host}:#{MYSQL.port}/#{MYSQL.database}")
 
 module MysqlSpecHelpers
   def insert(query, *args)
@@ -58,13 +67,8 @@ module MysqlSpecHelpers
   end
 
   def setup_test_environment
-    if JRUBY # use different, JDBC-style URLs for JRuby, for the time-being
-      @connection = DataObjects::Connection.new(DO_MYSQL_SPEC_JDBC_URI)
-      @secondary_connection = DataObjects::Connection.new(DO_MYSQL_SPEC_JDBC_URI)
-    elsif
-      @connection = DataObjects::Connection.new(DO_MYSQL_SPEC_URI)
-      @secondary_connection = DataObjects::Connection.new(DO_MYSQL_SPEC_URI)
-    end
+    @connection = DataObjects::Connection.new(DO_MYSQL_SPEC_URI)
+    @secondary_connection = DataObjects::Connection.new(DO_MYSQL_SPEC_URI)
 
     @connection.create_command(<<-EOF).execute_non_query
       DROP TABLE IF EXISTS `invoices`

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: do_mysql
 version: !ruby/object:Gem::Version 
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors: 
 - Scott Bauer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-27 00:00:00 -08:00
+date: 2009-01-04 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 0.9.9
+        version: 0.9.10
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
@@ -38,7 +38,7 @@ email:
 executables: []
 
 extensions: 
-- ext/extconf.rb
+- ext/do_mysql_ext/extconf.rb
 extra_rdoc_files: 
 - History.txt
 - Manifest.txt
@@ -55,8 +55,8 @@ files:
 - ext-java/src/main/java/DoMysqlExtService.java
 - ext-java/src/main/java/do_mysql/MySqlDriverDefinition.java
 - ext/.gitignore
-- ext/do_mysql_ext.c
-- ext/extconf.rb
+- ext/do_mysql_ext/do_mysql_ext.c
+- ext/do_mysql_ext/extconf.rb
 - lib/do_mysql.rb
 - lib/do_mysql/transaction.rb
 - lib/do_mysql/version.rb