mysql2 0.4.10 → 0.5.4

data/ext/mysql2/statement.c

@@ -1,12 +1,10 @@
 #include <mysql2_ext.h>
 
-VALUE cMysql2Statement;
-extern VALUE mMysql2, cMysql2Error, cBigDecimal, cDateTime, cDate;
-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
+extern VALUE mMysql2, cMysql2Error;
+static VALUE cMysql2Statement, cBigDecimal, cDateTime, cDate;
+static VALUE sym_stream, intern_new_with_args, intern_each, intern_to_s, intern_merge_bang;
+static VALUE intern_sec_fraction, intern_usec, intern_sec, intern_min, intern_hour, intern_day, intern_month, intern_year,
+  intern_query_options;
 
 #define GET_STATEMENT(self) \
   mysql_stmt_wrapper *stmt_wrapper; \
@@ -21,7 +19,7 @@ static void rb_mysql_stmt_mark(void * ptr) {
   rb_gc_mark(stmt_wrapper->client);
 }
 
-static void *nogvl_stmt_close(void * ptr) {
+static void *nogvl_stmt_close(void *ptr) {
   mysql_stmt_wrapper *stmt_wrapper = ptr;
   if (stmt_wrapper->stmt) {
     mysql_stmt_close(stmt_wrapper->stmt);
@@ -30,7 +28,7 @@ static void *nogvl_stmt_close(void * ptr) {
   return NULL;
 }
 
-static void rb_mysql_stmt_free(void * ptr) {
+static void rb_mysql_stmt_free(void *ptr) {
   mysql_stmt_wrapper *stmt_wrapper = ptr;
   decr_mysql2_stmt(stmt_wrapper);
 }
@@ -48,9 +46,8 @@ void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) {
   VALUE e;
   GET_CLIENT(stmt_wrapper->client);
   VALUE rb_error_msg = rb_str_new2(mysql_stmt_error(stmt_wrapper->stmt));
-  VALUE rb_sql_state = rb_tainted_str_new2(mysql_stmt_sqlstate(stmt_wrapper->stmt));
+  VALUE rb_sql_state = rb_str_new2(mysql_stmt_sqlstate(stmt_wrapper->stmt));
 
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *conn_enc;
   conn_enc = rb_to_encoding(wrapper->encoding);
 
@@ -62,7 +59,6 @@ void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) {
     rb_error_msg = rb_str_export_to_enc(rb_error_msg, default_internal_enc);
     rb_sql_state = rb_str_export_to_enc(rb_sql_state, default_internal_enc);
   }
-#endif
 
   e = rb_funcall(cMysql2Error, intern_new_with_args, 4,
                  rb_error_msg,
@@ -96,9 +92,7 @@ static void *nogvl_prepare_statement(void *ptr) {
 VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
   mysql_stmt_wrapper *stmt_wrapper;
   VALUE rb_stmt;
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *conn_enc;
-#endif
 
   Check_Type(sql, T_STRING);
 
@@ -114,9 +108,7 @@ VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
   {
     GET_CLIENT(rb_client);
     stmt_wrapper->stmt = mysql_stmt_init(wrapper->client);
-#ifdef HAVE_RUBY_ENCODING_H
     conn_enc = rb_to_encoding(wrapper->encoding);
-#endif
   }
   if (stmt_wrapper->stmt == NULL) {
     rb_raise(cMysql2Error, "Unable to initialize prepared statement: out of memory");
@@ -124,7 +116,7 @@ VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
 
   // set STMT_ATTR_UPDATE_MAX_LENGTH attr
   {
-    bool truth = 1;
+    my_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");
     }
@@ -134,11 +126,8 @@ VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
   {
     struct nogvl_prepare_statement_args args;
     args.stmt = stmt_wrapper->stmt;
-    args.sql = sql;
-#ifdef HAVE_RUBY_ENCODING_H
     // ensure the string is in the encoding the connection is expecting
-    args.sql = rb_str_export_to_enc(args.sql, conn_enc);
-#endif
+    args.sql = rb_str_export_to_enc(sql, conn_enc);
     args.sql_ptr = RSTRING_PTR(sql);
     args.sql_len = RSTRING_LEN(sql);
 
@@ -154,7 +143,7 @@ VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
  *
  * Returns the number of parameters the prepared statement expects.
  */
-static VALUE param_count(VALUE self) {
+static VALUE rb_mysql_stmt_param_count(VALUE self) {
   GET_STATEMENT(self);
 
   return ULL2NUM(mysql_stmt_param_count(stmt_wrapper->stmt));
@@ -164,13 +153,13 @@ static VALUE param_count(VALUE self) {
  *
  * Returns the number of fields the prepared statement returns.
  */
-static VALUE field_count(VALUE self) {
+static VALUE rb_mysql_stmt_field_count(VALUE self) {
   GET_STATEMENT(self);
 
   return UINT2NUM(mysql_stmt_field_count(stmt_wrapper->stmt));
 }
 
-static void *nogvl_execute(void *ptr) {
+static void *nogvl_stmt_execute(void *ptr) {
   MYSQL_STMT *stmt = ptr;
 
   if (mysql_stmt_execute(stmt)) {
@@ -196,7 +185,7 @@ static void set_buffer_for_string(MYSQL_BIND* bind_buffer, unsigned long *length
  * the buffer is a Ruby string pointer and not our memory to manage.
  */
 #define FREE_BINDS                                          \
-  for (i = 0; i < argc; i++) {                              \
+  for (i = 0; i < bind_count; i++) {                        \
     if (bind_buffers[i].buffer && NIL_P(params_enc[i])) {   \
       xfree(bind_buffers[i].buffer);                        \
     }                                                       \
@@ -211,6 +200,8 @@ static int my_big2ll(VALUE bignum, LONG_LONG *ptr)
 {
   unsigned LONG_LONG num;
   size_t len;
+// rb_absint_size was added in 2.1.0. See:
+// https://github.com/ruby/ruby/commit/9fea875
 #ifdef HAVE_RB_ABSINT_SIZE
   int nlz_bits = 0;
   len = rb_absint_size(bignum, &nlz_bits);
@@ -229,16 +220,15 @@ static int my_big2ll(VALUE bignum, LONG_LONG *ptr)
 #ifdef HAVE_RB_ABSINT_SIZE
         nlz_bits == 0 &&
 #endif
+// rb_absint_singlebit_p was added in 2.1.0. See:
+// https://github.com/ruby/ruby/commit/e5ff9d5
 #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)
+        rb_big_cmp(bignum, LL2NUM(LLONG_MIN)) == INT2FIX(-1)
 #endif
        ) {
       goto overflow;
@@ -254,44 +244,45 @@ overflow:
  *
  * Executes the current prepared statement, returns +result+.
  */
-static VALUE execute(int argc, VALUE *argv, VALUE self) {
+static VALUE rb_mysql_stmt_execute(int argc, VALUE *argv, VALUE self) {
   MYSQL_BIND *bind_buffers = NULL;
   unsigned long *length_buffers = NULL;
   unsigned long bind_count;
-  long i;
+  unsigned long i;
   MYSQL_STMT *stmt;
   MYSQL_RES *metadata;
+  VALUE opts;
   VALUE current;
   VALUE resultObj;
-  VALUE *params_enc;
+  VALUE *params_enc = NULL;
   int is_streaming;
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *conn_enc;
-#endif
 
   GET_STATEMENT(self);
   GET_CLIENT(stmt_wrapper->client);
 
-#ifdef HAVE_RUBY_ENCODING_H
   conn_enc = rb_to_encoding(wrapper->encoding);
-#endif
-
-  /* Scratch space for string encoding exports, allocate on the stack. */
-  params_enc = alloca(sizeof(VALUE) * argc);
 
   stmt = stmt_wrapper->stmt;
-
   bind_count = mysql_stmt_param_count(stmt);
-  if (argc != (long)bind_count) {
-    rb_raise(cMysql2Error, "Bind parameter count (%ld) doesn't match number of arguments (%d)", bind_count, argc);
+
+  // Get count of ordinary arguments, and extract hash opts/keyword arguments
+  // Use a local scope to avoid leaking the temporary count variable
+  {
+    int c = rb_scan_args(argc, argv, "*:", NULL, &opts);
+    if (c != (long)bind_count) {
+      rb_raise(cMysql2Error, "Bind parameter count (%ld) doesn't match number of arguments (%d)", bind_count, c);
+    }
   }
 
   // setup any bind variables in the query
   if (bind_count > 0) {
+    // Scratch space for string encoding exports, allocate on the stack
+    params_enc = alloca(sizeof(VALUE) * bind_count);
     bind_buffers = xcalloc(bind_count, sizeof(MYSQL_BIND));
     length_buffers = xcalloc(bind_count, sizeof(unsigned long));
 
-    for (i = 0; i < argc; i++) {
+    for (i = 0; i < bind_count; i++) {
       bind_buffers[i].buffer = NULL;
       params_enc[i] = Qnil;
 
@@ -319,12 +310,8 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
               *(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
+              params_enc[i] = rb_str_export_to_enc(rb_big2str(argv[i], 10), conn_enc);
               set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
             }
           }
@@ -338,9 +325,7 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
           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);
-#endif
           set_buffer_for_string(&bind_buffers[i], &length_buffers[i], params_enc[i]);
           break;
         case T_TRUE:
@@ -405,9 +390,7 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
             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;
@@ -421,7 +404,40 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
     }
   }
 
-  if ((VALUE)rb_thread_call_without_gvl(nogvl_execute, stmt, RUBY_UBF_IO, 0) == Qfalse) {
+  // Duplicate the options hash, merge! extra opts, put the copy into the Result object
+  current = rb_hash_dup(rb_ivar_get(stmt_wrapper->client, intern_query_options));
+  (void)RB_GC_GUARD(current);
+  Check_Type(current, T_HASH);
+
+  // Merge in hash opts/keyword arguments
+  if (!NIL_P(opts)) {
+    rb_funcall(current, intern_merge_bang, 1, opts);
+  }
+
+  is_streaming = (Qtrue == rb_hash_aref(current, sym_stream));
+
+  // From stmt_execute to mysql_stmt_result_metadata to stmt_store_result, no
+  // Ruby API calls are allowed so that GC is not invoked. If the connection is
+  // in results-streaming-mode for Statement A, and in the middle Statement B
+  // gets garbage collected, a message will be sent to the server notifying it
+  // to release Statement B, resulting in the following error:
+  //   Commands out of sync; you can't run this command now
+  //
+  // In streaming mode, statement execute must return a cursor because we
+  // cannot prevent other Statement objects from being garbage collected
+  // between fetches of each row of the result set. The following error
+  // occurs if cursor mode is not set:
+  //   Row retrieval was canceled by mysql_stmt_close
+
+  if (is_streaming) {
+    unsigned long type = CURSOR_TYPE_READ_ONLY;
+    if (mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, &type)) {
+      FREE_BINDS;
+      rb_raise(cMysql2Error, "Unable to stream prepared statement, could not set CURSOR_TYPE_READ_ONLY");
+    }
+  }
+
+  if ((VALUE)rb_thread_call_without_gvl(nogvl_stmt_execute, stmt, RUBY_UBF_IO, 0) == Qfalse) {
     FREE_BINDS;
     rb_raise_mysql2_stmt_error(stmt_wrapper);
   }
@@ -439,13 +455,8 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
     return Qnil;
   }
 
-  current = rb_hash_dup(rb_iv_get(stmt_wrapper->client, "@query_options"));
-  (void)RB_GC_GUARD(current);
-  Check_Type(current, T_HASH);
-
-  is_streaming = (Qtrue == rb_hash_aref(current, sym_stream));
   if (!is_streaming) {
-    // recieve the whole result set from the server
+    // receive the whole result set from the server
     if (mysql_stmt_store_result(stmt)) {
       mysql_free_result(metadata);
       rb_raise_mysql2_stmt_error(stmt_wrapper);
@@ -455,6 +466,8 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
 
   resultObj = rb_mysql_result_to_obj(stmt_wrapper->client, wrapper->encoding, current, metadata, self);
 
+  rb_mysql_set_server_query_flags(wrapper->client, resultObj);
+
   if (!is_streaming) {
     // cache all result
     rb_funcall(resultObj, intern_each, 0);
@@ -467,27 +480,23 @@ static VALUE execute(int argc, VALUE *argv, VALUE self) {
  *
  * Returns a list of fields that will be returned by this statement.
  */
-static VALUE fields(VALUE self) {
+static VALUE rb_mysql_stmt_fields(VALUE self) {
   MYSQL_FIELD *fields;
   MYSQL_RES *metadata;
   unsigned int field_count;
   unsigned int i;
   VALUE field_list;
   MYSQL_STMT* stmt;
-#ifdef HAVE_RUBY_ENCODING_H
   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
   default_internal_enc = rb_default_internal_encoding();
   {
     GET_CLIENT(stmt_wrapper->client);
     conn_enc = rb_to_encoding(wrapper->encoding);
   }
-#endif
 
   metadata = mysql_stmt_result_metadata(stmt);
   if (metadata == NULL) {
@@ -508,12 +517,10 @@ static VALUE fields(VALUE self) {
     VALUE rb_field;
 
     rb_field = rb_str_new(fields[i].name, fields[i].name_length);
-#ifdef HAVE_RUBY_ENCODING_H
     rb_enc_associate(rb_field, conn_enc);
     if (default_internal_enc) {
      rb_field = rb_str_export_to_enc(rb_field, default_internal_enc);
    }
-#endif
 
     rb_ary_store(field_list, (long)i, rb_field);
   }
@@ -564,12 +571,23 @@ static VALUE rb_mysql_stmt_close(VALUE self) {
 }
 
 void init_mysql2_statement() {
+  cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+  rb_global_variable(&cDate);
+
+  cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+  rb_global_variable(&cDateTime);
+
+  cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+  rb_global_variable(&cBigDecimal);
+
   cMysql2Statement = rb_define_class_under(mMysql2, "Statement", rb_cObject);
+  rb_undef_alloc_func(cMysql2Statement);
+  rb_global_variable(&cMysql2Statement);
 
-  rb_define_method(cMysql2Statement, "param_count", param_count, 0);
-  rb_define_method(cMysql2Statement, "field_count", field_count, 0);
-  rb_define_method(cMysql2Statement, "_execute", execute, -1);
-  rb_define_method(cMysql2Statement, "fields", fields, 0);
+  rb_define_method(cMysql2Statement, "param_count", rb_mysql_stmt_param_count, 0);
+  rb_define_method(cMysql2Statement, "field_count", rb_mysql_stmt_field_count, 0);
+  rb_define_method(cMysql2Statement, "_execute", rb_mysql_stmt_execute, -1);
+  rb_define_method(cMysql2Statement, "fields", rb_mysql_stmt_fields, 0);
   rb_define_method(cMysql2Statement, "last_id", rb_mysql_stmt_last_id, 0);
   rb_define_method(cMysql2Statement, "affected_rows", rb_mysql_stmt_affected_rows, 0);
   rb_define_method(cMysql2Statement, "close", rb_mysql_stmt_close, 0);
@@ -589,7 +607,6 @@ void init_mysql2_statement() {
   intern_year = rb_intern("year");
 
   intern_to_s = rb_intern("to_s");
-#ifndef HAVE_RB_BIG_CMP
-  id_cmp = rb_intern("<=>");
-#endif
+  intern_merge_bang = rb_intern("merge!");
+  intern_query_options = rb_intern("@query_options");
 }

data/ext/mysql2/statement.h

@@ -1,8 +1,6 @@
 #ifndef MYSQL2_STATEMENT_H
 #define MYSQL2_STATEMENT_H
 
-extern VALUE cMysql2Statement;
-
 typedef struct {
   VALUE client;
   MYSQL_STMT *stmt;

data/ext/mysql2/wait_for_single_fd.h

@@ -1,5 +1,6 @@
 /*
- * backwards compatibility for pre-1.9.3 C API
+ * backwards compatibility for Rubinius. See
+ * https://github.com/rubinius/rubinius/issues/3771.
  *
  * Ruby 1.9.3 provides this API which allows the use of ppoll() on Linux
  * to minimize select() and malloc() overhead on high-numbered FDs.

data/lib/mysql2/client.rb

@@ -4,22 +4,22 @@ module Mysql2
 
     def self.default_query_options
       @default_query_options ||= {
-        :as => :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
-        :async => false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
-        :cast_booleans => false,        # cast tinyint(1) fields as true/false in ruby
-        :symbolize_keys => false,       # return field names as symbols instead of strings
-        :database_timezone => :local,   # timezone Mysql2 will assume datetime objects are stored in
-        :application_timezone => nil,   # timezone Mysql2 will convert to before handing the object back to the caller
-        :cache_rows => true,            # tells Mysql2 to use its internal row cache for results
-        :connect_flags => REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION,
-        :cast => true,
-        :default_file => nil,
-        :default_group => nil,
+        as: :hash,                   # the type of object you want each row back as; also supports :array (an array of values)
+        async: false,                # don't wait for a result after sending the query, you'll have to monitor the socket yourself then eventually call Mysql2::Client#async_result
+        cast_booleans: false,        # cast tinyint(1) fields as true/false in ruby
+        symbolize_keys: false,       # return field names as symbols instead of strings
+        database_timezone: :local,   # timezone Mysql2 will assume datetime objects are stored in
+        application_timezone: nil,   # timezone Mysql2 will convert to before handing the object back to the caller
+        cache_rows: true,            # tells Mysql2 to use its internal row cache for results
+        connect_flags: REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION | CONNECT_ATTRS,
+        cast: true,
+        default_file: nil,
+        default_group: nil,
       }
     end
 
     def initialize(opts = {})
-      fail Mysql2::Error, "Options parameter must be a Hash" unless opts.is_a? Hash
+      raise 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
@@ -31,7 +31,7 @@ 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, :automatic_close, :enable_cleartext_plugin].each do |key|
+      %i[reconnect connect_timeout local_infile read_timeout write_timeout default_file default_group secure_auth init_command automatic_close enable_cleartext_plugin default_auth].each do |key|
         next unless opts.key?(key)
         case key
         when :reconnect, :local_infile, :secure_auth, :automatic_close, :enable_cleartext_plugin
@@ -46,25 +46,30 @@ module Mysql2
       # force the encoding to utf8
       self.charset_name = opts[:encoding] || 'utf8'
 
+      mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
+      if (mode == SSL_MODE_VERIFY_CA || mode == SSL_MODE_VERIFY_IDENTITY) && !opts[:sslca]
+        opts[:sslca] = find_default_ca_path
+      end
+
       ssl_options = opts.values_at(:sslkey, :sslcert, :sslca, :sslcapath, :sslcipher)
       ssl_set(*ssl_options) if ssl_options.any? || opts.key?(:sslverify)
-      self.ssl_mode = parse_ssl_mode(opts[:ssl_mode]) if opts[:ssl_mode]
+      self.ssl_mode = mode if mode
 
-      case opts[:flags]
+      flags = case opts[:flags]
       when Array
-        flags = parse_flags_array(opts[:flags], @query_options[:connect_flags])
+        parse_flags_array(opts[:flags], @query_options[:connect_flags])
       when String
-        flags = parse_flags_array(opts[:flags].split(' '), @query_options[:connect_flags])
+        parse_flags_array(opts[:flags].split(' '), @query_options[:connect_flags])
       when Integer
-        flags = @query_options[:connect_flags] | opts[:flags]
+        @query_options[:connect_flags] | opts[:flags]
       else
-        flags = @query_options[:connect_flags]
+        @query_options[:connect_flags]
       end
 
       # SSL verify is a connection flag rather than a mysql_ssl_set option
       flags |= SSL_VERIFY_SERVER_CERT if opts[:sslverify]
 
-      if [:user, :pass, :hostname, :dbname, :db, :sock].any? { |k| @query_options.key?(k) }
+      if %i[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 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."
@@ -85,8 +90,9 @@ module Mysql2
       port = port.to_i unless port.nil?
       database = database.to_s unless database.nil?
       socket = socket.to_s unless socket.nil?
+      conn_attrs = parse_connect_attrs(opts[:connect_attrs])
 
-      connect user, pass, host, port, database, socket, flags
+      connect user, pass, host, port, database, socket, flags, conn_attrs
     end
 
     def parse_ssl_mode(mode)
@@ -114,14 +120,31 @@ module Mysql2
       end
     end
 
-    if Thread.respond_to?(:handle_interrupt)
-      def query(sql, options = {})
-        Thread.handle_interrupt(::Mysql2::Util::TimeoutError => :never) do
-          _query(sql, @query_options.merge(options))
-        end
+    # Find any default system CA paths to handle system roots
+    # by default if stricter validation is requested and no
+    # path is provide.
+    def find_default_ca_path
+      [
+        "/etc/ssl/certs/ca-certificates.crt",
+        "/etc/pki/tls/certs/ca-bundle.crt",
+        "/etc/ssl/ca-bundle.pem",
+        "/etc/ssl/cert.pem",
+      ].find { |f| File.exist?(f) }
+    end
+
+    # Set default program_name in performance_schema.session_connect_attrs
+    # and performance_schema.session_account_connect_attrs
+    def parse_connect_attrs(conn_attrs)
+      return {} if Mysql2::Client::CONNECT_ATTRS.zero?
+      conn_attrs ||= {}
+      conn_attrs[:program_name] ||= $PROGRAM_NAME
+      conn_attrs.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = value.to_s
       end
-    else
-      def query(sql, options = {})
+    end
+
+    def query(sql, options = {})
+      Thread.handle_interrupt(::Mysql2::Util::TIMEOUT_ERROR_NEVER) do
         _query(sql, @query_options.merge(options))
       end
     end

data/lib/mysql2/em.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'eventmachine'
 require 'mysql2'
 
@@ -17,7 +15,7 @@ module Mysql2
           detach
           begin
             result = @client.async_result
-          rescue => e
+          rescue StandardError => e
             @deferable.fail(e)
           else
             @deferable.succeed(result)
@@ -41,7 +39,7 @@ module Mysql2
 
       def query(sql, opts = {})
         if ::EM.reactor_running?
-          super(sql, opts.merge(:async => true))
+          super(sql, opts.merge(async: true))
           deferable = ::EM::DefaultDeferrable.new
           @watch = ::EM.watch(socket, Watcher, self, deferable)
           @watch.notify_readable = true

data/lib/mysql2/error.rb

@@ -1,32 +1,66 @@
-# encoding: UTF-8
-
 module Mysql2
   class Error < StandardError
     ENCODE_OPTS = {
-      :undef => :replace,
-      :invalid => :replace,
-      :replace => '?'.freeze,
+      undef: :replace,
+      invalid: :replace,
+      replace: '?'.freeze,
+    }.freeze
+
+    ConnectionError = Class.new(Error)
+    TimeoutError = Class.new(Error)
+
+    CODES = {
+      1205 => TimeoutError, # ER_LOCK_WAIT_TIMEOUT
+
+      1044 => ConnectionError, # ER_DBACCESS_DENIED_ERROR
+      1045 => ConnectionError, # ER_ACCESS_DENIED_ERROR
+      1152 => ConnectionError, # ER_ABORTING_CONNECTION
+      1153 => ConnectionError, # ER_NET_PACKET_TOO_LARGE
+      1154 => ConnectionError, # ER_NET_READ_ERROR_FROM_PIPE
+      1155 => ConnectionError, # ER_NET_FCNTL_ERROR
+      1156 => ConnectionError, # ER_NET_PACKETS_OUT_OF_ORDER
+      1157 => ConnectionError, # ER_NET_UNCOMPRESS_ERROR
+      1158 => ConnectionError, # ER_NET_READ_ERROR
+      1159 => ConnectionError, # ER_NET_READ_INTERRUPTED
+      1160 => ConnectionError, # ER_NET_ERROR_ON_WRITE
+      1161 => ConnectionError, # ER_NET_WRITE_INTERRUPTED
+      1927 => ConnectionError, # ER_CONNECTION_KILLED
+
+      2001 => ConnectionError, # CR_SOCKET_CREATE_ERROR
+      2002 => ConnectionError, # CR_CONNECTION_ERROR
+      2003 => ConnectionError, # CR_CONN_HOST_ERROR
+      2004 => ConnectionError, # CR_IPSOCK_ERROR
+      2005 => ConnectionError, # CR_UNKNOWN_HOST
+      2006 => ConnectionError, # CR_SERVER_GONE_ERROR
+      2007 => ConnectionError, # CR_VERSION_ERROR
+      2009 => ConnectionError, # CR_WRONG_HOST_INFO
+      2012 => ConnectionError, # CR_SERVER_HANDSHAKE_ERR
+      2013 => ConnectionError, # CR_SERVER_LOST
+      2020 => ConnectionError, # CR_NET_PACKET_TOO_LARGE
+      2026 => ConnectionError, # CR_SSL_CONNECTION_ERROR
+      2027 => ConnectionError, # CR_MALFORMED_PACKET
+      2047 => ConnectionError, # CR_CONN_UNKNOW_PROTOCOL
+      2048 => ConnectionError, # CR_INVALID_CONN_HANDLE
+      2049 => ConnectionError, # CR_UNUSED_1
     }.freeze
 
     attr_reader :error_number, :sql_state
 
     # Mysql gem compatibility
-    alias_method :errno, :error_number
-    alias_method :error, :message
+    alias errno error_number
+    alias error message
 
-    def initialize(msg)
-      @server_version ||= nil
+    def initialize(msg, server_version = nil, error_number = nil, sql_state = nil)
+      @server_version = server_version
+      @error_number = error_number
+      @sql_state = sql_state ? sql_state.encode(**ENCODE_OPTS) : nil
 
       super(clean_message(msg))
     end
 
     def self.new_with_args(msg, server_version, error_number, sql_state)
-      err = allocate
-      err.instance_variable_set('@server_version', server_version)
-      err.instance_variable_set('@error_number', error_number)
-      err.instance_variable_set('@sql_state', sql_state.respond_to?(:encode) ? sql_state.encode(ENCODE_OPTS) : sql_state)
-      err.send(:initialize, msg)
-      err
+      error_class = CODES.fetch(error_number, self)
+      error_class.new(msg, server_version, error_number, sql_state)
     end
 
     private
@@ -55,16 +89,12 @@ module Mysql2
     # encoding, we'll assume UTF-8 and clean the string of anything that's not a
     # valid UTF-8 character.
     #
-    # Except for if we're on 1.8, where we'll do nothing ;)
-    #
-    # Returns a valid UTF-8 string in Ruby 1.9+, the original string on Ruby 1.8
+    # Returns a valid UTF-8 string.
     def clean_message(message)
-      return message unless message.respond_to?(:encode)
-
       if @server_version && @server_version > 50500
-        message.encode(ENCODE_OPTS)
+        message.encode(**ENCODE_OPTS)
       else
-        message.encode(Encoding::UTF_8, ENCODE_OPTS)
+        message.encode(Encoding::UTF_8, **ENCODE_OPTS)
       end
     end
   end

data/lib/mysql2/result.rb

@@ -1,5 +1,7 @@
 module Mysql2
   class Result
+    attr_reader :server_flags
+
     include Enumerable
   end
 end