mysql2 0.4.2 → 0.4.10

data/ext/mysql2/result.c

@@ -104,6 +104,10 @@ static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
         wrapper->stmt_wrapper->stmt->bind_result_done = 0;
       }
 
+      if (wrapper->statement != Qnil) {
+        decr_mysql2_stmt(wrapper->stmt_wrapper);
+      }
+
       if (wrapper->result_buffers) {
         unsigned int i;
         for (i = 0; i < wrapper->numberOfFields; i++) {
@@ -136,13 +140,15 @@ static void rb_mysql_result_free(void *ptr) {
     decr_mysql2_client(wrapper->client_wrapper);
   }
 
-  if (wrapper->statement != Qnil) {
-    decr_mysql2_stmt(wrapper->stmt_wrapper);
-  }
-
   xfree(wrapper);
 }
 
+static VALUE rb_mysql_result_free_(VALUE self) {
+  GET_RESULT(self);
+  rb_mysql_result_free_result(wrapper);
+  return Qnil;
+}
+
 /*
  * for small results, this won't hit the network, but there's no
  * reliable way for us to tell this so we'll always release the GVL
@@ -256,8 +262,8 @@ static void rb_mysql_result_alloc_result_buffers(VALUE self, MYSQL_FIELD *fields
   if (wrapper->result_buffers != NULL) return;
 
   wrapper->result_buffers = xcalloc(wrapper->numberOfFields, sizeof(MYSQL_BIND));
-  wrapper->is_null = xcalloc(wrapper->numberOfFields, sizeof(my_bool));
-  wrapper->error = xcalloc(wrapper->numberOfFields, sizeof(my_bool));
+  wrapper->is_null = xcalloc(wrapper->numberOfFields, sizeof(bool));
+  wrapper->error = xcalloc(wrapper->numberOfFields, sizeof(bool));
   wrapper->length = xcalloc(wrapper->numberOfFields, sizeof(unsigned long));
 
   for (i = 0; i < wrapper->numberOfFields; i++) {
@@ -340,15 +346,15 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
   conn_enc = rb_to_encoding(wrapper->encoding);
 #endif
 
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
   if (args->asArray) {
     rowVal = rb_ary_new2(wrapper->numberOfFields);
   } else {
     rowVal = rb_hash_new();
   }
-  if (wrapper->fields == Qnil) {
-    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
-    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
-  }
 
   if (wrapper->result_buffers == NULL) {
     rb_mysql_result_alloc_result_buffers(self, fields);
@@ -399,6 +405,13 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
             val = INT2NUM(*((signed char*)result_buffer->buffer));
           }
           break;
+        case MYSQL_TYPE_BIT:        /* BIT field (MySQL 5.0.3 and up) */
+          if (args->castBool && fields[i].length == 1) {
+            val = (*((unsigned char*)result_buffer->buffer) != 0) ? Qtrue : Qfalse;
+          }else{
+            val = rb_str_new(result_buffer->buffer, *(result_buffer->length));
+          }
+          break;
         case MYSQL_TYPE_SHORT:        // short int
           if (result_buffer->is_unsigned) {
             val = UINT2NUM(*((unsigned short int*)result_buffer->buffer));
@@ -488,7 +501,6 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
         case MYSQL_TYPE_BLOB:         // char[]
         case MYSQL_TYPE_MEDIUM_BLOB:  // char[]
         case MYSQL_TYPE_LONG_BLOB:    // char[]
-        case MYSQL_TYPE_BIT:          // char[]
         case MYSQL_TYPE_SET:          // char[]
         case MYSQL_TYPE_ENUM:         // char[]
         case MYSQL_TYPE_GEOMETRY:     // char[]
@@ -511,7 +523,6 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
   return rowVal;
 }
 
-
 static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const result_each_args *args)
 {
   VALUE rowVal;
@@ -536,16 +547,16 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const r
     return Qnil;
   }
 
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
   if (args->asArray) {
     rowVal = rb_ary_new2(wrapper->numberOfFields);
   } else {
     rowVal = rb_hash_new();
   }
   fieldLengths = mysql_fetch_lengths(wrapper->result);
-  if (wrapper->fields == Qnil) {
-    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
-    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
-  }
 
   for (i = 0; i < wrapper->numberOfFields; i++) {
     VALUE field = rb_mysql_result_fetch_field(self, i, args->symbolizeKeys);
@@ -829,7 +840,9 @@ static VALUE rb_mysql_result_each_(VALUE self,
 
         if (row == Qnil) {
           /* we don't need the mysql C dataset around anymore, peace it */
-          rb_mysql_result_free_result(wrapper);
+          if (args->cacheRows) {
+            rb_mysql_result_free_result(wrapper);
+          }
           return Qnil;
         }
 
@@ -837,7 +850,7 @@ static VALUE rb_mysql_result_each_(VALUE self,
           rb_yield(row);
         }
       }
-      if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
+      if (wrapper->lastRowProcessed == wrapper->numberOfRows && args->cacheRows) {
         /* we don't need the mysql C dataset around anymore, peace it */
         rb_mysql_result_free_result(wrapper);
       }
@@ -881,6 +894,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
   if (wrapper->stmt_wrapper && !cacheRows && !wrapper->is_streaming) {
     rb_warn(":cache_rows is forced for prepared statements (if not streaming)");
+    cacheRows = 1;
   }
 
   if (wrapper->stmt_wrapper && !cast) {
@@ -908,12 +922,15 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     app_timezone = Qnil;
   }
 
-  if (wrapper->lastRowProcessed == 0 && !wrapper->is_streaming) {
+  if (wrapper->rows == Qnil && !wrapper->is_streaming) {
     wrapper->numberOfRows = wrapper->stmt_wrapper ? mysql_stmt_num_rows(wrapper->stmt_wrapper->stmt) : mysql_num_rows(wrapper->result);
-    if (wrapper->numberOfRows == 0) {
-      wrapper->rows = rb_ary_new();
-      return wrapper->rows;
+    wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
+  } else if (wrapper->rows && !cacheRows) {
+    if (wrapper->resultFreed) {
+      rb_raise(cMysql2Error, "Result set has already been freed");
     }
+    mysql_data_seek(wrapper->result, 0);
+    wrapper->lastRowProcessed = 0;
     wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
   }
 
@@ -1007,6 +1024,7 @@ void init_mysql2_result() {
   cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
   rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
   rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0);
+  rb_define_method(cMysql2Result, "free", rb_mysql_result_free_, 0);
   rb_define_method(cMysql2Result, "count", rb_mysql_result_count, 0);
   rb_define_alias(cMysql2Result, "size", "count");
 

data/ext/mysql2/result.h

@@ -1,5 +1,6 @@
 #ifndef MYSQL2_RESULT_H
 #define MYSQL2_RESULT_H
+#include <stdbool.h>
 
 void init_mysql2_result(void);
 VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_RES *r, VALUE statement);
@@ -21,8 +22,8 @@ typedef struct {
   mysql_client_wrapper *client_wrapper;
   /* statement result bind buffers */
   MYSQL_BIND *result_buffers;
-  my_bool *is_null;
-  my_bool *error;
+  bool *is_null;
+  bool *error;
   unsigned long *length;
 } mysql2_result_wrapper;
 

data/ext/mysql2/statement.c

@@ -2,8 +2,11 @@
 
 VALUE cMysql2Statement;
 extern VALUE mMysql2, cMysql2Error, cBigDecimal, cDateTime, cDate;
-static VALUE sym_stream, intern_new_with_args, intern_each;
-static VALUE intern_usec, intern_sec, intern_min, intern_hour, intern_day, intern_month, intern_year;
+static VALUE sym_stream, intern_new_with_args, intern_each, intern_to_s;
+static VALUE intern_sec_fraction, intern_usec, intern_sec, intern_min, intern_hour, intern_day, intern_month, intern_year;
+#ifndef HAVE_RB_BIG_CMP
+static ID id_cmp;
+#endif
 
 #define GET_STATEMENT(self) \
   mysql_stmt_wrapper *stmt_wrapper; \
@@ -11,7 +14,6 @@ static VALUE intern_usec, intern_sec, intern_min, intern_hour, intern_day, inter
   if (!stmt_wrapper->stmt) { rb_raise(cMysql2Error, "Invalid statement handle"); } \
   if (stmt_wrapper->closed) { rb_raise(cMysql2Error, "Statement handle already closed"); }
 
-
 static void rb_mysql_stmt_mark(void * ptr) {
   mysql_stmt_wrapper *stmt_wrapper = ptr;
   if (!stmt_wrapper) return;
@@ -42,7 +44,6 @@ void decr_mysql2_stmt(mysql_stmt_wrapper *stmt_wrapper) {
   }
 }
 
-
 void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) {
   VALUE e;
   GET_CLIENT(stmt_wrapper->client);
@@ -71,7 +72,6 @@ void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) {
   rb_exc_raise(e);
 }
 
-
 /*
  * used to pass all arguments to mysql_stmt_prepare while inside
  * nogvl_prepare_statement_args
@@ -124,7 +124,7 @@ VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
 
   // set STMT_ATTR_UPDATE_MAX_LENGTH attr
   {
-    my_bool truth = 1;
+    bool truth = 1;
     if (mysql_stmt_attr_set(stmt_wrapper->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &truth)) {
       rb_raise(cMysql2Error, "Unable to initialize prepared statement: set STMT_ATTR_UPDATE_MAX_LENGTH");
     }
@@ -180,14 +180,16 @@ static void *nogvl_execute(void *ptr) {
   }
 }
 
-static void *nogvl_stmt_store_result(void *ptr) {
-  MYSQL_STMT *stmt = ptr;
+static void set_buffer_for_string(MYSQL_BIND* bind_buffer, unsigned long *length_buffer, VALUE string) {
+  unsigned long length;
 
-  if (mysql_stmt_store_result(stmt)) {
-    return (void *)Qfalse;
-  } else {
-    return (void *)Qtrue;
-  }
+  bind_buffer->buffer = RSTRING_PTR(string);
+
+  length = RSTRING_LEN(string);
+  bind_buffer->buffer_length = length;
+  *length_buffer = length;
+
+  bind_buffer->length = length_buffer;
 }
 
 /* Free each bind_buffer[i].buffer except when params_enc is non-nil, this means
@@ -204,6 +206,50 @@ static void *nogvl_stmt_store_result(void *ptr) {
     xfree(length_buffers);                                  \
   }
 
+/* return 0 if the given bignum can cast as LONG_LONG, otherwise 1 */
+static int my_big2ll(VALUE bignum, LONG_LONG *ptr)
+{
+  unsigned LONG_LONG num;
+  size_t len;
+#ifdef HAVE_RB_ABSINT_SIZE
+  int nlz_bits = 0;
+  len = rb_absint_size(bignum, &nlz_bits);
+#else
+  len = RBIGNUM_LEN(bignum) * SIZEOF_BDIGITS;
+#endif
+  if (len > sizeof(LONG_LONG)) goto overflow;
+  if (RBIGNUM_POSITIVE_P(bignum)) {
+    num = rb_big2ull(bignum);
+    if (num > LLONG_MAX)
+      goto overflow;
+    *ptr = num;
+  }
+  else {
+    if (len == 8 &&
+#ifdef HAVE_RB_ABSINT_SIZE
+        nlz_bits == 0 &&
+#endif
+#if defined(HAVE_RB_ABSINT_SIZE) && defined(HAVE_RB_ABSINT_SINGLEBIT_P)
+        /* Optimized to avoid object allocation for Ruby 2.1+
+         * only -0x8000000000000000 is safe if `len == 8 && nlz_bits == 0`
+         */
+        !rb_absint_singlebit_p(bignum)
+#elif defined(HAVE_RB_BIG_CMP)
+        rb_big_cmp(bignum, LL2NUM(LLONG_MIN)) == INT2FIX(-1)
+#else
+        /* Ruby 1.8.7 and REE doesn't have rb_big_cmp */
+        rb_funcall(bignum, id_cmp, 1, LL2NUM(LLONG_MIN)) == INT2FIX(-1)
+#endif
+       ) {
+      goto overflow;
+    }
+    *ptr = rb_big2ll(bignum);
+  }
+  return 0;
+overflow:
+  return 1;
+}
+
 /* call-seq: stmt.execute
  *
  * Executes the current prepared statement, returns +result+.
@@ -265,9 +311,23 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
 #endif
           break;
         case T_BIGNUM:
-          bind_buffers[i].buffer_type = MYSQL_TYPE_LONGLONG;
-          bind_buffers[i].buffer = xmalloc(sizeof(long long int));
-          *(LONG_LONG*)(bind_buffers[i].buffer) = rb_big2ll(argv[i]);
+          {
+            LONG_LONG num;
+            if (my_big2ll(argv[i], &num) == 0) {
+              bind_buffers[i].buffer_type = MYSQL_TYPE_LONGLONG;
+              bind_buffers[i].buffer = xmalloc(sizeof(long long int));
+              *(LONG_LONG*)(bind_buffers[i].buffer) = num;
+            } else {
+              /* The bignum was larger than we can fit in LONG_LONG, send it as a string */
+              VALUE rb_val_as_string = rb_big2str(argv[i], 10);
+              bind_buffers[i].buffer_type = MYSQL_TYPE_NEWDECIMAL;
+              params_enc[i] = rb_val_as_string;
+#ifdef HAVE_RUBY_ENCODING_H
+              params_enc[i] = rb_str_export_to_enc(params_enc[i], conn_enc);
+#endif
+              set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
+            }
+          }
           break;
         case T_FLOAT:
           bind_buffers[i].buffer_type = MYSQL_TYPE_DOUBLE;
@@ -275,17 +335,23 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
           *(double*)(bind_buffers[i].buffer) = NUM2DBL(argv[i]);
           break;
         case T_STRING:
-          {
-            params_enc[i] = argv[i];
+          bind_buffers[i].buffer_type = MYSQL_TYPE_STRING;
+
+          params_enc[i] = argv[i];
 #ifdef HAVE_RUBY_ENCODING_H
-            params_enc[i] = rb_str_export_to_enc(params_enc[i], conn_enc);
+          params_enc[i] = rb_str_export_to_enc(params_enc[i], conn_enc);
 #endif
-            bind_buffers[i].buffer_type = MYSQL_TYPE_STRING;
-            bind_buffers[i].buffer = RSTRING_PTR(params_enc[i]);
-            bind_buffers[i].buffer_length = RSTRING_LEN(params_enc[i]);
-            length_buffers[i] = bind_buffers[i].buffer_length;
-            bind_buffers[i].length = &length_buffers[i];
-          }
+          set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
+          break;
+        case T_TRUE:
+          bind_buffers[i].buffer_type = MYSQL_TYPE_TINY;
+          bind_buffers[i].buffer = xmalloc(sizeof(signed char));
+          *(signed char*)(bind_buffers[i].buffer) = 1;
+          break;
+        case T_FALSE:
+          bind_buffers[i].buffer_type = MYSQL_TYPE_TINY;
+          bind_buffers[i].buffer = xmalloc(sizeof(signed char));
+          *(signed char*)(bind_buffers[i].buffer) = 0;
           break;
         default:
           // TODO: what Ruby type should support MYSQL_TYPE_TIME
@@ -298,7 +364,13 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
 
             memset(&t, 0, sizeof(MYSQL_TIME));
             t.neg = 0;
-            t.second_part = FIX2INT(rb_funcall(rb_time, intern_usec, 0));
+
+            if (CLASS_OF(argv[i]) == rb_cTime) {
+              t.second_part = FIX2INT(rb_funcall(rb_time, intern_usec, 0));
+            } else if (CLASS_OF(argv[i]) == cDateTime) {
+              t.second_part = NUM2DBL(rb_funcall(rb_time, intern_sec_fraction, 0)) * 1000000;
+            }
+
             t.second = FIX2INT(rb_funcall(rb_time, intern_sec, 0));
             t.minute = FIX2INT(rb_funcall(rb_time, intern_min, 0));
             t.hour = FIX2INT(rb_funcall(rb_time, intern_hour, 0));
@@ -324,6 +396,19 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
             *(MYSQL_TIME*)(bind_buffers[i].buffer) = t;
           } else if (CLASS_OF(argv[i]) == cBigDecimal) {
             bind_buffers[i].buffer_type = MYSQL_TYPE_NEWDECIMAL;
+
+            // DECIMAL are represented with the "string representation of the
+            // original server-side value", see
+            // https://dev.mysql.com/doc/refman/5.7/en/c-api-prepared-statement-type-conversions.html
+            // This should be independent of the locale used both on the server
+            // and the client side.
+            VALUE rb_val_as_string = rb_funcall(argv[i], intern_to_s, 0);
+
+            params_enc[i] = rb_val_as_string;
+#ifdef HAVE_RUBY_ENCODING_H
+            params_enc[i] = rb_str_export_to_enc(params_enc[i], conn_enc);
+#endif
+            set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
           }
           break;
       }
@@ -347,8 +432,7 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
   if (metadata == NULL) {
     if (mysql_stmt_errno(stmt) != 0) {
       // either CR_OUT_OF_MEMORY or CR_UNKNOWN_ERROR. both fatal.
-
-      MARK_CONN_INACTIVE(stmt_wrapper->client);
+      wrapper->active_thread = Qnil;
       rb_raise_mysql2_stmt_error(stmt_wrapper);
     }
     // no data and no error, so query was not a SELECT
@@ -362,11 +446,11 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
   is_streaming = (Qtrue == rb_hash_aref(current, sym_stream));
   if (!is_streaming) {
     // recieve the whole result set from the server
-    if (rb_thread_call_without_gvl(nogvl_stmt_store_result, stmt, RUBY_UBF_IO, 0) == Qfalse) {
+    if (mysql_stmt_store_result(stmt)) {
       mysql_free_result(metadata);
       rb_raise_mysql2_stmt_error(stmt_wrapper);
     }
-    MARK_CONN_INACTIVE(stmt_wrapper->client);
+    wrapper->active_thread = Qnil;
   }
 
   resultObj = rb_mysql_result_to_obj(stmt_wrapper->client, wrapper->encoding, current, metadata, self);
@@ -394,6 +478,7 @@ static VALUE fields(VALUE self) {
   rb_encoding *default_internal_enc, *conn_enc;
 #endif
   GET_STATEMENT(self);
+  GET_CLIENT(stmt_wrapper->client);
   stmt = stmt_wrapper->stmt;
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -404,12 +489,22 @@ static VALUE fields(VALUE self) {
   }
 #endif
 
-  metadata    = mysql_stmt_result_metadata(stmt);
+  metadata = mysql_stmt_result_metadata(stmt);
+  if (metadata == NULL) {
+    if (mysql_stmt_errno(stmt) != 0) {
+      // either CR_OUT_OF_MEMORY or CR_UNKNOWN_ERROR. both fatal.
+      wrapper->active_thread = Qnil;
+      rb_raise_mysql2_stmt_error(stmt_wrapper);
+    }
+    // no data and no error, so query was not a SELECT
+    return Qnil;
+  }
+
   fields      = mysql_fetch_fields(metadata);
   field_count = mysql_stmt_field_count(stmt);
   field_list  = rb_ary_new2((long)field_count);
 
-  for(i = 0; i < field_count; i++) {
+  for (i = 0; i < field_count; i++) {
     VALUE rb_field;
 
     rb_field = rb_str_new(fields[i].name, fields[i].name_length);
@@ -484,6 +579,7 @@ void init_mysql2_statement() {
   intern_new_with_args = rb_intern("new_with_args");
   intern_each = rb_intern("each");
 
+  intern_sec_fraction = rb_intern("sec_fraction");
   intern_usec = rb_intern("usec");
   intern_sec = rb_intern("sec");
   intern_min = rb_intern("min");
@@ -491,4 +587,9 @@ void init_mysql2_statement() {
   intern_day = rb_intern("day");
   intern_month = rb_intern("month");
   intern_year = rb_intern("year");
+
+  intern_to_s = rb_intern("to_s");
+#ifndef HAVE_RB_BIG_CMP
+  id_cmp = rb_intern("<=>");
+#endif
 }

data/lib/mysql2/client.rb

@@ -19,6 +19,7 @@ module Mysql2
     end
 
     def initialize(opts = {})
+      fail Mysql2::Error, "Options parameter must be a Hash" unless opts.is_a? Hash
       opts = Mysql2::Util.key_hash_as_symbols(opts)
       @read_timeout = nil
       @query_options = self.class.default_query_options.dup
@@ -30,13 +31,13 @@ module Mysql2
       opts[:connect_timeout] = 120 unless opts.key?(:connect_timeout)
 
       # TODO: stricter validation rather than silent massaging
-      [:reconnect, :connect_timeout, :local_infile, :read_timeout, :write_timeout, :default_file, :default_group, :secure_auth, :init_command].each do |key|
+      [:reconnect, :connect_timeout, :local_infile, :read_timeout, :write_timeout, :default_file, :default_group, :secure_auth, :init_command, :automatic_close, :enable_cleartext_plugin].each do |key|
         next unless opts.key?(key)
         case key
-        when :reconnect, :local_infile, :secure_auth
+        when :reconnect, :local_infile, :secure_auth, :automatic_close, :enable_cleartext_plugin
           send(:"#{key}=", !!opts[key]) # rubocop:disable Style/DoubleNegation
         when :connect_timeout, :read_timeout, :write_timeout
-          send(:"#{key}=", opts[key].to_i)
+          send(:"#{key}=", Integer(opts[key])) unless opts[key].nil?
         else
           send(:"#{key}=", opts[key])
         end
@@ -46,7 +47,8 @@ module Mysql2
       self.charset_name = opts[:encoding] || 'utf8'
 
       ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
-      ssl_set(*ssl_options) if ssl_options.any?
+      ssl_set(*ssl_options) if ssl_options.any? || opts.key?(:sslverify)
+      self.ssl_mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
 
       case opts[:flags]
       when Array
@@ -60,11 +62,11 @@ module Mysql2
       end
 
       # SSL verify is a connection flag rather than a mysql_ssl_set option
-      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify] && ssl_options.any?
+      flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify]
 
       if [:user, :pass, :hostname, :dbname, :db, :sock].any? { |k| @query_options.key?(k) }
         warn "============= WARNING FROM mysql2 ============="
-        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock will be deprecated at some point in the future."
+        warn "The options :user, :pass, :hostname, :dbname, :db, and :sock are deprecated and will be removed at some point in the future."
         warn "Instead, please use :username, :password, :host, :port, :database, :socket, :flags for the options."
         warn "============= END WARNING FROM mysql2 ========="
       end
@@ -87,6 +89,17 @@ module Mysql2
       connect user, pass, host, port, database, socket, flags
     end
 
+    def parse_ssl_mode(mode)
+      m = mode.to_s.upcase
+      if m.start_with?('SSL_MODE_')
+        return Mysql2::Client.const_get(m) if Mysql2::Client.const_defined?(m)
+      else
+        x = 'SSL_MODE_' + m
+        return Mysql2::Client.const_get(x) if Mysql2::Client.const_defined?(x)
+      end
+      warn "Unknown MySQL ssl_mode flag: #{mode}"
+    end
+
     def parse_flags_array(flags, initial = 0)
       flags.reduce(initial) do |memo, f|
         fneg = f.start_with?('-') ? f[1..-1] : nil

data/lib/mysql2/version.rb

@@ -1,3 +1,3 @@
 module Mysql2
-  VERSION = "0.4.2"
+  VERSION = "0.4.10"
 end

data/spec/configuration.yml.example

@@ -9,9 +9,3 @@ user:
   username: LOCALUSERNAME
   password:
   database: mysql2_test
-
-numericuser:
-  host: localhost
-  username: LOCALUSERNAME
-  password:
-  database: 12345

data/spec/em/em_spec.rb

@@ -70,6 +70,7 @@ begin
       let(:client) { Mysql2::EM::Client.new DatabaseCredentials['root'] }
       let(:error) { StandardError.new('some error') }
       before { allow(client).to receive(:async_result).and_raise(error) }
+      after { client.close }
 
       it "should swallow exceptions raised in by the client" do
         errors = []