mysql2 0.4.2 → 0.5.5

data/ext/mysql2/client.c

@@ -15,38 +15,73 @@
 #include "mysql_enc_name_to_ruby.h"
 
 VALUE cMysql2Client;
-extern VALUE mMysql2, cMysql2Error;
+extern VALUE mMysql2, cMysql2Error, cMysql2TimeoutError;
 static VALUE sym_id, sym_version, sym_header_version, sym_async, sym_symbolize_keys, sym_as, sym_array, sym_stream;
-static ID intern_brackets, intern_merge, intern_merge_bang, intern_new_with_args;
-
-#ifndef HAVE_RB_HASH_DUP
-VALUE rb_hash_dup(VALUE other) {
-  return rb_funcall(rb_cHash, intern_brackets, 1, other);
-}
-#endif
+static VALUE sym_no_good_index_used, sym_no_index_used, sym_query_was_slow;
+static ID intern_brackets, intern_merge, intern_merge_bang, intern_new_with_args,
+  intern_current_query_options, intern_read_timeout;
 
 #define REQUIRE_INITIALIZED(wrapper) \
   if (!wrapper->initialized) { \
     rb_raise(cMysql2Error, "MySQL client is not initialized"); \
   }
 
+#if defined(HAVE_MYSQL_NET_VIO) || defined(HAVE_ST_NET_VIO)
+  #define CONNECTED(wrapper) (wrapper->client->net.vio != NULL && wrapper->client->net.fd != -1)
+#elif defined(HAVE_MYSQL_NET_PVIO) || defined(HAVE_ST_NET_PVIO)
+  #define CONNECTED(wrapper) (wrapper->client->net.pvio != NULL && wrapper->client->net.fd != -1)
+#endif
+
+#define REQUIRE_CONNECTED(wrapper) \
+  REQUIRE_INITIALIZED(wrapper) \
+  if (!CONNECTED(wrapper) && !wrapper->reconnect_enabled) { \
+    rb_raise(cMysql2Error, "MySQL client is not connected"); \
+  }
+
 #define REQUIRE_NOT_CONNECTED(wrapper) \
   REQUIRE_INITIALIZED(wrapper) \
-  if (wrapper->connected) { \
+  if (CONNECTED(wrapper)) { \
     rb_raise(cMysql2Error, "MySQL connection is already open"); \
   }
 
 /*
- * compatability with mysql-connector-c, where LIBMYSQL_VERSION is the correct
+ * compatibility with mysql-connector-c, where LIBMYSQL_VERSION is the correct
  * variable to use, but MYSQL_SERVER_VERSION gives the correct numbers when
  * linking against the server itself
  */
-#ifdef LIBMYSQL_VERSION
+#if defined(MARIADB_CLIENT_VERSION_STR)
+  #define MYSQL_LINK_VERSION MARIADB_CLIENT_VERSION_STR
+#elif defined(LIBMYSQL_VERSION)
   #define MYSQL_LINK_VERSION LIBMYSQL_VERSION
 #else
   #define MYSQL_LINK_VERSION MYSQL_SERVER_VERSION
 #endif
 
+/*
+ * mariadb-connector-c defines CLIENT_SESSION_TRACKING and SESSION_TRACK_TRANSACTION_TYPE
+ * while mysql-connector-c defines CLIENT_SESSION_TRACK and SESSION_TRACK_TRANSACTION_STATE
+ * This is a hack to take care of both clients.
+ */
+#if defined(CLIENT_SESSION_TRACK)
+#elif defined(CLIENT_SESSION_TRACKING)
+  #define CLIENT_SESSION_TRACK CLIENT_SESSION_TRACKING
+  #define SESSION_TRACK_TRANSACTION_STATE SESSION_TRACK_TRANSACTION_TYPE
+#endif
+
+/*
+ * compatibility with mysql-connector-c 6.1.x, MySQL 5.7.3 - 5.7.10 & with MariaDB 10.x and later.
+ */
+#ifdef HAVE_CONST_MYSQL_OPT_SSL_VERIFY_SERVER_CERT
+  #define SSL_MODE_VERIFY_IDENTITY 5
+  #define HAVE_CONST_SSL_MODE_VERIFY_IDENTITY
+#endif
+#ifdef HAVE_CONST_MYSQL_OPT_SSL_ENFORCE
+  #define SSL_MODE_DISABLED 1
+  #define SSL_MODE_REQUIRED 3
+  #define HAVE_CONST_SSL_MODE_DISABLED
+  #define HAVE_CONST_SSL_MODE_REQUIRED
+#endif
+
 /*
  * used to pass all arguments to mysql_real_connect while inside
  * rb_thread_call_without_gvl
@@ -83,6 +118,82 @@ struct nogvl_select_db_args {
   char *db;
 };
 
+static VALUE rb_set_ssl_mode_option(VALUE self, VALUE setting) {
+  unsigned long version = mysql_get_client_version();
+  const char *version_str = mysql_get_client_info();
+
+  /* Warn about versions that are known to be incomplete; these are pretty
+   * ancient, we want people to upgrade if they need SSL/TLS to work
+   *
+   * MySQL 5.x before 5.6.30 -- ssl_mode introduced but not fully working until 5.6.36)
+   * MySQL 5.7 before 5.7.3 -- ssl_mode introduced but not fully working until 5.7.11)
+   */
+  if ((version >= 50000 && version < 50630) || (version >= 50700 && version < 50703)) {
+    rb_warn("Your mysql client library version %s does not support setting ssl_mode; full support comes with 5.6.36+, 5.7.11+, 8.0+", version_str);
+    return Qnil;
+  }
+
+  /* For these versions, map from the options we're exposing to Ruby to the constant available:
+   *   ssl_mode: :verify_identity to MYSQL_OPT_SSL_VERIFY_SERVER_CERT = 1
+   *   ssl_mode: :required to MYSQL_OPT_SSL_ENFORCE = 1
+   *   ssl_mode: :disabled to MYSQL_OPT_SSL_ENFORCE = 0
+   */
+#if defined(HAVE_CONST_MYSQL_OPT_SSL_VERIFY_SERVER_CERT) || defined(HAVE_CONST_MYSQL_OPT_SSL_ENFORCE)
+  GET_CLIENT(self);
+  int val = NUM2INT(setting);
+
+  /* Expected code path for MariaDB 10.x and MariaDB Connector/C 3.x
+   * Workaround code path for MySQL 5.7.3 - 5.7.10 and MySQL Connector/C 6.1.3 - 6.1.x
+   */
+  if (version >= 100000                         // MariaDB (all versions numbered 10.x)
+    || (version >= 30000 && version < 40000)    // MariaDB Connector/C (all versions numbered 3.x)
+    || (version >= 50703 && version < 50711)    // Workaround for MySQL 5.7.3 - 5.7.10
+    || (version >= 60103 && version < 60200)) { // Workaround for MySQL Connector/C 6.1.3 - 6.1.x
+#ifdef HAVE_CONST_MYSQL_OPT_SSL_VERIFY_SERVER_CERT
+    if (val == SSL_MODE_VERIFY_IDENTITY) {
+      my_bool b = 1;
+      int result = mysql_options(wrapper->client, MYSQL_OPT_SSL_VERIFY_SERVER_CERT, &b);
+      return INT2NUM(result);
+    }
+#endif
+#ifdef HAVE_CONST_MYSQL_OPT_SSL_ENFORCE
+    if (val == SSL_MODE_DISABLED || val == SSL_MODE_REQUIRED) {
+      my_bool b = (val == SSL_MODE_REQUIRED);
+      int result = mysql_options(wrapper->client, MYSQL_OPT_SSL_ENFORCE, &b);
+      return INT2NUM(result);
+    }
+#endif
+    rb_warn("Your mysql client library version %s does not support ssl_mode %d", version_str, val);
+    return Qnil;
+  } else {
+    rb_warn("Your mysql client library version %s does not support ssl_mode as expected", version_str);
+    return Qnil;
+  }
+#endif
+
+  /* For other versions -- known to be MySQL 5.6.36+, 5.7.11+, 8.0+
+   * pass the value of the argument to MYSQL_OPT_SSL_MODE -- note the code
+   * mapping from atoms / constants is in the MySQL::Client Ruby class
+   */
+#ifdef FULL_SSL_MODE_SUPPORT
+  GET_CLIENT(self);
+  int val = NUM2INT(setting);
+
+  if (val != SSL_MODE_DISABLED && val != SSL_MODE_PREFERRED && val != SSL_MODE_REQUIRED && val != SSL_MODE_VERIFY_CA && val != SSL_MODE_VERIFY_IDENTITY) {
+    rb_raise(cMysql2Error, "ssl_mode= takes DISABLED, PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY, you passed: %d", val );
+  }
+  int result = mysql_options(wrapper->client, MYSQL_OPT_SSL_MODE, &val);
+
+  return INT2NUM(result);
+#endif
+
+  // Warn if we get this far
+#ifdef NO_SSL_MODE_SUPPORT
+  rb_warn("Your mysql client library does not support setting ssl_mode");
+  return Qnil;
+#endif
+}
+
 /*
  * non-blocking mysql_*() functions that we won't be wrapping since
  * they do not appear to hit the network nor issue any interruptible
@@ -108,20 +219,54 @@ struct nogvl_select_db_args {
 static void rb_mysql_client_mark(void * wrapper) {
   mysql_client_wrapper * w = wrapper;
   if (w) {
-    rb_gc_mark(w->encoding);
-    rb_gc_mark(w->active_thread);
+    rb_gc_mark_movable(w->encoding);
+    rb_gc_mark_movable(w->active_fiber);
   }
 }
 
+/* this is called during GC */
+static void rb_mysql_client_free(void *ptr) {
+  mysql_client_wrapper *wrapper = ptr;
+  decr_mysql2_client(wrapper);
+}
+
+static size_t rb_mysql_client_memsize(const void * wrapper) {
+  const mysql_client_wrapper * w = wrapper;
+  return sizeof(*w);
+}
+
+static void rb_mysql_client_compact(void * wrapper) {
+  mysql_client_wrapper * w = wrapper;
+  if (w) {
+    rb_mysql2_gc_location(w->encoding);
+    rb_mysql2_gc_location(w->active_fiber);
+  }
+}
+
+const rb_data_type_t rb_mysql_client_type = {
+  "rb_mysql_client",
+  {
+    rb_mysql_client_mark,
+    rb_mysql_client_free,
+    rb_mysql_client_memsize,
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+    rb_mysql_client_compact,
+#endif
+  },
+  0,
+  0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
 static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
   VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
-  VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
+  VALUE rb_sql_state = rb_str_new2(mysql_sqlstate(wrapper->client));
   VALUE e;
 
-#ifdef HAVE_RUBY_ENCODING_H
   rb_enc_associate(rb_error_msg, rb_utf8_encoding());
   rb_enc_associate(rb_sql_state, rb_usascii_encoding());
-#endif
 
   e = rb_funcall(cMysql2Error, intern_new_with_args, 4,
                  rb_error_msg,
@@ -211,30 +356,23 @@ static VALUE invalidate_fd(int clientfd)
 static void *nogvl_close(void *ptr) {
   mysql_client_wrapper *wrapper = ptr;
 
-  if (wrapper->client) {
+  if (wrapper->initialized && !wrapper->closed) {
     mysql_close(wrapper->client);
-    xfree(wrapper->client);
-    wrapper->client = NULL;
-    wrapper->connected = 0;
-    wrapper->active_thread = Qnil;
+    wrapper->closed = 1;
+    wrapper->reconnect_enabled = 0;
+    wrapper->active_fiber = Qnil;
   }
 
   return NULL;
 }
 
-/* this is called during GC */
-static void rb_mysql_client_free(void *ptr) {
-  mysql_client_wrapper *wrapper = ptr;
-  decr_mysql2_client(wrapper);
-}
-
 void decr_mysql2_client(mysql_client_wrapper *wrapper)
 {
   wrapper->refcount--;
 
   if (wrapper->refcount == 0) {
 #ifndef _WIN32
-    if (wrapper->connected) {
+    if (CONNECTED(wrapper) && !wrapper->automatic_close) {
       /* The client is being garbage collected while connected. Prevent
        * mysql_close() from sending a mysql-QUIT or from calling shutdown() on
        * the socket by invalidating it. invalidate_fd() will drop this
@@ -246,10 +384,12 @@ void decr_mysql2_client(mysql_client_wrapper *wrapper)
         fprintf(stderr, "[WARN] mysql2 failed to invalidate FD safely\n");
         close(wrapper->client->net.fd);
       }
+      wrapper->client->net.fd = -1;
     }
 #endif
 
     nogvl_close(wrapper);
+    xfree(wrapper->client);
     xfree(wrapper);
   }
 }
@@ -257,14 +397,19 @@ void decr_mysql2_client(mysql_client_wrapper *wrapper)
 static VALUE allocate(VALUE klass) {
   VALUE obj;
   mysql_client_wrapper * wrapper;
+#ifdef NEW_TYPEDDATA_WRAPPER
+  obj = TypedData_Make_Struct(klass, mysql_client_wrapper, &rb_mysql_client_type, wrapper);
+#else
   obj = Data_Make_Struct(klass, mysql_client_wrapper, rb_mysql_client_mark, rb_mysql_client_free, wrapper);
+#endif
   wrapper->encoding = Qnil;
-  MARK_CONN_INACTIVE(self);
+  wrapper->active_fiber = Qnil;
+  wrapper->automatic_close = 1;
   wrapper->server_version = 0;
   wrapper->reconnect_enabled = 0;
   wrapper->connect_timeout = 0;
-  wrapper->connected = 0; /* means that a database connection is open */
-  wrapper->initialized = 0; /* means that that the wrapper is initialized */
+  wrapper->initialized = 0; /* will be set true after calling mysql_init */
+  wrapper->closed = 1; /* will be set false after calling mysql_real_connect */
   wrapper->refcount = 1;
   wrapper->client = (MYSQL*)xmalloc(sizeof(MYSQL));
 
@@ -295,9 +440,7 @@ static VALUE rb_mysql_client_escape(RB_MYSQL_UNUSED VALUE klass, VALUE str) {
     return str;
   } else {
     rb_str = rb_str_new((const char*)newStr, newLen);
-#ifdef HAVE_RUBY_ENCODING_H
     rb_enc_copy(rb_str, str);
-#endif
     xfree(newStr);
     return rb_str;
   }
@@ -324,14 +467,43 @@ static VALUE rb_mysql_info(VALUE self) {
   }
 
   rb_str = rb_str_new2(info);
-#ifdef HAVE_RUBY_ENCODING_H
   rb_enc_associate(rb_str, rb_utf8_encoding());
-#endif
 
   return rb_str;
 }
 
-static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE port, VALUE database, VALUE socket, VALUE flags) {
+static VALUE rb_mysql_get_ssl_cipher(VALUE self)
+{
+  const char *cipher;
+  VALUE rb_str;
+  GET_CLIENT(self);
+
+  cipher = mysql_get_ssl_cipher(wrapper->client);
+
+  if (cipher == NULL) {
+    return Qnil;
+  }
+
+  rb_str = rb_str_new2(cipher);
+  rb_enc_associate(rb_str, rb_utf8_encoding());
+
+  return rb_str;
+}
+
+#ifdef CLIENT_CONNECT_ATTRS
+static int opt_connect_attr_add_i(VALUE key, VALUE value, VALUE arg)
+{
+  mysql_client_wrapper *wrapper = (mysql_client_wrapper *)arg;
+  rb_encoding *enc = rb_to_encoding(wrapper->encoding);
+  key = rb_str_export_to_enc(key, enc);
+  value = rb_str_export_to_enc(value, enc);
+
+  mysql_options4(wrapper->client, MYSQL_OPT_CONNECT_ATTR_ADD, StringValueCStr(key), StringValueCStr(value));
+  return ST_CONTINUE;
+}
+#endif
+
+static VALUE rb_mysql_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE port, VALUE database, VALUE socket, VALUE flags, VALUE conn_attrs) {
   struct nogvl_connect_args args;
   time_t start_time, end_time, elapsed_time, connect_timeout;
   VALUE rv;
@@ -346,6 +518,11 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
   args.mysql       = wrapper->client;
   args.client_flag = NUM2ULONG(flags);
 
+#ifdef CLIENT_CONNECT_ATTRS
+  mysql_options(wrapper->client, MYSQL_OPT_CONNECT_ATTR_RESET, 0);
+  rb_hash_foreach(conn_attrs, opt_connect_attr_add_i, (VALUE)wrapper);
+#endif
+
   if (wrapper->connect_timeout)
     time(&start_time);
   rv = (VALUE) rb_thread_call_without_gvl(nogvl_connect, &args, RUBY_UBF_IO, 0);
@@ -372,33 +549,42 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
     if (wrapper->connect_timeout)
       mysql_options(wrapper->client, MYSQL_OPT_CONNECT_TIMEOUT, &wrapper->connect_timeout);
     if (rv == Qfalse)
-      return rb_raise_mysql2_error(wrapper);
+      rb_raise_mysql2_error(wrapper);
   }
 
+  wrapper->closed = 0;
   wrapper->server_version = mysql_get_server_version(wrapper->client);
-  wrapper->connected = 1;
   return self;
 }
 
 /*
- * Terminate the connection; call this when the connection is no longer needed.
- * The garbage collector can close the connection, but doing so emits an
- * "Aborted connection" error on the server and increments the Aborted_clients
- * status variable.
+ * Immediately disconnect from the server; normally the garbage collector
+ * will disconnect automatically when a connection is no longer needed.
+ * Explicitly closing this will free up server resources sooner than waiting
+ * for the garbage collector.
  *
- * @see http://dev.mysql.com/doc/en/communication-errors.html
- * @return [void]
+ * @return [nil]
  */
 static VALUE rb_mysql_client_close(VALUE self) {
   GET_CLIENT(self);
 
-  if (wrapper->connected) {
+  if (wrapper->client) {
     rb_thread_call_without_gvl(nogvl_close, wrapper, RUBY_UBF_IO, 0);
   }
 
   return Qnil;
 }
 
+/* call-seq:
+ *    client.closed?
+ *
+ * @return [Boolean]
+ */
+static VALUE rb_mysql_client_closed(VALUE self) {
+  GET_CLIENT(self);
+  return CONNECTED(wrapper) ? Qfalse : Qtrue;
+}
+
 /*
  * mysql_send_query is unlikely to block since most queries are small
  * enough to fit in a socket buffer, but sometimes large UPDATE and
@@ -413,13 +599,13 @@ static void *nogvl_send_query(void *ptr) {
   return (void*)(rv == 0 ? Qtrue : Qfalse);
 }
 
-static VALUE do_send_query(void *args) {
-  struct nogvl_send_query_args *query_args = args;
+static VALUE do_send_query(VALUE args) {
+  struct nogvl_send_query_args *query_args = (void *)args;
   mysql_client_wrapper *wrapper = query_args->wrapper;
-  if ((VALUE)rb_thread_call_without_gvl(nogvl_send_query, args, RUBY_UBF_IO, 0) == Qfalse) {
+  if ((VALUE)rb_thread_call_without_gvl(nogvl_send_query, query_args, RUBY_UBF_IO, 0) == Qfalse) {
     /* an error occurred, we're not active anymore */
-    MARK_CONN_INACTIVE(self);
-    return rb_raise_mysql2_error(wrapper);
+    wrapper->active_fiber = Qnil;
+    rb_raise_mysql2_error(wrapper);
   }
   return Qnil;
 }
@@ -448,7 +634,7 @@ static void *nogvl_do_result(void *ptr, char use_result) {
 
   /* once our result is stored off, this connection is
      ready for another command to be issued */
-  MARK_CONN_INACTIVE(self);
+  wrapper->active_fiber = Qnil;
 
   return result;
 }
@@ -474,17 +660,17 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
   GET_CLIENT(self);
 
   /* if we're not waiting on a result, do nothing */
-  if (NIL_P(wrapper->active_thread))
+  if (NIL_P(wrapper->active_fiber))
     return Qnil;
 
   REQUIRE_CONNECTED(wrapper);
   if ((VALUE)rb_thread_call_without_gvl(nogvl_read_query_result, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
     /* an error occurred, mark this connection inactive */
-    MARK_CONN_INACTIVE(self);
-    return rb_raise_mysql2_error(wrapper);
+    wrapper->active_fiber = Qnil;
+    rb_raise_mysql2_error(wrapper);
   }
 
-  is_streaming = rb_hash_aref(rb_iv_get(self, "@current_query_options"), sym_stream);
+  is_streaming = rb_hash_aref(rb_ivar_get(self, intern_current_query_options), sym_stream);
   if (is_streaming == Qtrue) {
     result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
   } else {
@@ -493,18 +679,21 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
 
   if (result == NULL) {
     if (mysql_errno(wrapper->client) != 0) {
-      MARK_CONN_INACTIVE(self);
+      wrapper->active_fiber = Qnil;
       rb_raise_mysql2_error(wrapper);
     }
     /* no data and no error, so query was not a SELECT */
     return Qnil;
   }
 
-  current = rb_hash_dup(rb_iv_get(self, "@current_query_options"));
+  // Duplicate the options hash and put the copy in the Result object
+  current = rb_hash_dup(rb_ivar_get(self, intern_current_query_options));
   (void)RB_GC_GUARD(current);
   Check_Type(current, T_HASH);
   resultObj = rb_mysql_result_to_obj(self, wrapper->encoding, current, result, Qnil);
 
+  rb_mysql_set_server_query_flags(wrapper->client, resultObj);
+
   return resultObj;
 }
 
@@ -517,29 +706,31 @@ struct async_query_args {
 static VALUE disconnect_and_raise(VALUE self, VALUE error) {
   GET_CLIENT(self);
 
-  MARK_CONN_INACTIVE(self);
-  wrapper->connected = 0;
+  wrapper->active_fiber = Qnil;
 
   /* Invalidate the MySQL socket to prevent further communication.
    * The GC will come along later and call mysql_close to free it.
    */
-  if (invalidate_fd(wrapper->client->net.fd) == Qfalse) {
-    fprintf(stderr, "[WARN] mysql2 failed to invalidate FD safely, closing unsafely\n");
-    close(wrapper->client->net.fd);
+  if (CONNECTED(wrapper)) {
+    if (invalidate_fd(wrapper->client->net.fd) == Qfalse) {
+      fprintf(stderr, "[WARN] mysql2 failed to invalidate FD safely, closing unsafely\n");
+      close(wrapper->client->net.fd);
+    }
+    wrapper->client->net.fd = -1;
   }
 
   rb_exc_raise(error);
 }
 
-static VALUE do_query(void *args) {
-  struct async_query_args *async_args = args;
+static VALUE do_query(VALUE args) {
+  struct async_query_args *async_args = (void *)args;
   struct timeval tv;
   struct timeval *tvp;
   long int sec;
   int retval;
   VALUE read_timeout;
 
-  read_timeout = rb_iv_get(async_args->self, "@read_timeout");
+  read_timeout = rb_ivar_get(async_args->self, intern_read_timeout);
 
   tvp = NULL;
   if (!NIL_P(read_timeout)) {
@@ -560,7 +751,7 @@ static VALUE do_query(void *args) {
     retval = rb_wait_for_single_fd(async_args->fd, RB_WAITFD_IN, tvp);
 
     if (retval == 0) {
-      rb_raise(cMysql2Error, "Timeout waiting for a response from the last query. (waited %d seconds)", FIX2INT(read_timeout));
+      rb_raise(cMysql2TimeoutError, "Timeout waiting for a response from the last query. (waited %d seconds)", FIX2INT(read_timeout));
     }
 
     if (retval < 0) {
@@ -574,39 +765,45 @@ static VALUE do_query(void *args) {
 
   return Qnil;
 }
-#else
-static VALUE finish_and_mark_inactive(void *args) {
-  VALUE self = args;
-  MYSQL_RES *result;
+#endif
 
+static VALUE disconnect_and_mark_inactive(VALUE self) {
   GET_CLIENT(self);
 
-  if (!NIL_P(wrapper->active_thread)) {
-    /* if we got here, the result hasn't been read off the wire yet
-       so lets do that and then throw it away because we have no way
-       of getting it back up to the caller from here */
-    result = (MYSQL_RES *)rb_thread_call_without_gvl(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
-    mysql_free_result(result);
-
-    MARK_CONN_INACTIVE(self);
+  /* Check if execution terminated while result was still being read. */
+  if (!NIL_P(wrapper->active_fiber)) {
+    if (CONNECTED(wrapper)) {
+      /* Invalidate the MySQL socket to prevent further communication. */
+#ifndef _WIN32
+      if (invalidate_fd(wrapper->client->net.fd) == Qfalse) {
+        rb_warn("mysql2 failed to invalidate FD safely, closing unsafely\n");
+        close(wrapper->client->net.fd);
+      }
+#else
+      close(wrapper->client->net.fd);
+#endif
+      wrapper->client->net.fd = -1;
+    }
+    /* Skip mysql client check performed before command execution. */
+    wrapper->client->status = MYSQL_STATUS_READY;
+    wrapper->active_fiber = Qnil;
   }
 
   return Qnil;
 }
-#endif
 
-void rb_mysql_client_set_active_thread(VALUE self) {
-  VALUE thread_current = rb_thread_current();
+static void rb_mysql_client_set_active_fiber(VALUE self) {
+  VALUE fiber_current = rb_fiber_current();
   GET_CLIENT(self);
 
   // see if this connection is still waiting on a result from a previous query
-  if (NIL_P(wrapper->active_thread)) {
+  if (NIL_P(wrapper->active_fiber)) {
     // mark this connection active
-    wrapper->active_thread = thread_current;
-  } else if (wrapper->active_thread == thread_current) {
+    wrapper->active_fiber = fiber_current;
+  } else if (wrapper->active_fiber == fiber_current) {
     rb_raise(cMysql2Error, "This connection is still waiting for a result, try again once you have the result");
   } else {
-    VALUE inspect = rb_inspect(wrapper->active_thread);
+    VALUE inspect = rb_inspect(wrapper->active_fiber);
     const char *thr = StringValueCStr(inspect);
 
     rb_raise(cMysql2Error, "This connection is in use by: %s", thr);
@@ -649,7 +846,7 @@ static VALUE rb_mysql_client_abandon_results(VALUE self) {
  * Query the database with +sql+, with optional +options+.  For the possible
  * options, see default_query_options on the Mysql2::Client class.
  */
-static VALUE rb_query(VALUE self, VALUE sql, VALUE current) {
+static VALUE rb_mysql_query(VALUE self, VALUE sql, VALUE current) {
 #ifndef _WIN32
   struct async_query_args async_args;
 #endif
@@ -661,23 +858,20 @@ static VALUE rb_query(VALUE self, VALUE sql, VALUE current) {
 
   (void)RB_GC_GUARD(current);
   Check_Type(current, T_HASH);
-  rb_iv_set(self, "@current_query_options", current);
+  rb_ivar_set(self, intern_current_query_options, current);
 
   Check_Type(sql, T_STRING);
-#ifdef HAVE_RUBY_ENCODING_H
   /* ensure the string is in the encoding the connection is expecting */
   args.sql = rb_str_export_to_enc(sql, rb_to_encoding(wrapper->encoding));
-#else
-  args.sql = sql;
-#endif
   args.sql_ptr = RSTRING_PTR(args.sql);
   args.sql_len = RSTRING_LEN(args.sql);
   args.wrapper = wrapper;
 
-  rb_mysql_client_set_active_thread(self);
+  rb_mysql_client_set_active_fiber(self);
 
 #ifndef _WIN32
   rb_rescue2(do_send_query, (VALUE)&args, disconnect_and_raise, self, rb_eException, (VALUE)0);
+  (void)RB_GC_GUARD(sql);
 
   if (rb_hash_aref(current, sym_async) == Qtrue) {
     return Qnil;
@@ -687,13 +881,14 @@ static VALUE rb_query(VALUE self, VALUE sql, VALUE current) {
 
     rb_rescue2(do_query, (VALUE)&async_args, disconnect_and_raise, self, rb_eException, (VALUE)0);
 
-    return rb_mysql_client_async_result(self);
+    return rb_ensure(rb_mysql_client_async_result, self, disconnect_and_mark_inactive, self);
   }
 #else
-  do_send_query(&args);
+  do_send_query((VALUE)&args);
+  (void)RB_GC_GUARD(sql);
 
   /* this will just block until the result is ready */
-  return rb_ensure(rb_mysql_client_async_result, self, finish_and_mark_inactive, self);
+  return rb_ensure(rb_mysql_client_async_result, self, disconnect_and_mark_inactive, self);
 #endif
 }
 
@@ -706,20 +901,16 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
   unsigned char *newStr;
   VALUE rb_str;
   unsigned long newLen, oldLen;
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc;
   rb_encoding *conn_enc;
-#endif
   GET_CLIENT(self);
 
   REQUIRE_CONNECTED(wrapper);
   Check_Type(str, T_STRING);
-#ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
   conn_enc = rb_to_encoding(wrapper->encoding);
   /* ensure the string is in the encoding the connection is expecting */
   str = rb_str_export_to_enc(str, conn_enc);
-#endif
 
   oldLen = RSTRING_LEN(str);
   newStr = xmalloc(oldLen*2+1);
@@ -727,21 +918,17 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
   newLen = mysql_real_escape_string(wrapper->client, (char *)newStr, RSTRING_PTR(str), oldLen);
   if (newLen == oldLen) {
     /* no need to return a new ruby string if nothing changed */
-#ifdef HAVE_RUBY_ENCODING_H
     if (default_internal_enc) {
       str = rb_str_export_to_enc(str, default_internal_enc);
     }
-#endif
     xfree(newStr);
     return str;
   } else {
     rb_str = rb_str_new((const char*)newStr, newLen);
-#ifdef HAVE_RUBY_ENCODING_H
     rb_enc_associate(rb_str, conn_enc);
     if (default_internal_enc) {
       rb_str = rb_str_export_to_enc(rb_str, default_internal_enc);
     }
-#endif
     xfree(newStr);
     return rb_str;
   }
@@ -787,10 +974,12 @@ static VALUE _mysql_client_options(VALUE self, int opt, VALUE value) {
       retval = &boolval;
       break;
 
+#ifdef MYSQL_SECURE_AUTH
     case MYSQL_SECURE_AUTH:
       boolval = (value == Qfalse ? 0 : 1);
       retval = &boolval;
       break;
+#endif
 
     case MYSQL_READ_DEFAULT_FILE:
       charval = (const char *)StringValueCStr(value);
@@ -807,6 +996,20 @@ static VALUE _mysql_client_options(VALUE self, int opt, VALUE value) {
       retval  = charval;
       break;
 
+#ifdef HAVE_MYSQL_DEFAULT_AUTH
+    case MYSQL_DEFAULT_AUTH:
+      charval = (const char *)StringValueCStr(value);
+      retval  = charval;
+      break;
+#endif
+
+#ifdef HAVE_CONST_MYSQL_ENABLE_CLEARTEXT_PLUGIN
+    case MYSQL_ENABLE_CLEARTEXT_PLUGIN:
+      boolval = (value == Qfalse ? 0 : 1);
+      retval = &boolval;
+      break;
+#endif
+
     default:
       return Qfalse;
   }
@@ -843,10 +1046,8 @@ static VALUE rb_mysql_client_info(RB_MYSQL_UNUSED VALUE klass) {
   version = rb_str_new2(mysql_get_client_info());
   header_version = rb_str_new2(MYSQL_LINK_VERSION);
 
-#ifdef HAVE_RUBY_ENCODING_H
   rb_enc_associate(version, rb_usascii_encoding());
   rb_enc_associate(header_version, rb_usascii_encoding());
-#endif
 
   rb_hash_aset(version_info, sym_id, LONG2NUM(mysql_get_client_version()));
   rb_hash_aset(version_info, sym_version, version);
@@ -862,27 +1063,21 @@ static VALUE rb_mysql_client_info(RB_MYSQL_UNUSED VALUE klass) {
  */
 static VALUE rb_mysql_client_server_info(VALUE self) {
   VALUE version, server_info;
-#ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *default_internal_enc;
   rb_encoding *conn_enc;
-#endif
   GET_CLIENT(self);
 
   REQUIRE_CONNECTED(wrapper);
-#ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
   conn_enc = rb_to_encoding(wrapper->encoding);
-#endif
 
   version = rb_hash_new();
   rb_hash_aset(version, sym_id, LONG2FIX(mysql_get_server_version(wrapper->client)));
   server_info = rb_str_new2(mysql_get_server_info(wrapper->client));
-#ifdef HAVE_RUBY_ENCODING_H
   rb_enc_associate(server_info, conn_enc);
   if (default_internal_enc) {
     server_info = rb_str_export_to_enc(server_info, default_internal_enc);
   }
-#endif
   rb_hash_aset(version, sym_version, server_info);
   return version;
 }
@@ -916,6 +1111,36 @@ static VALUE rb_mysql_client_last_id(VALUE self) {
   return ULL2NUM(mysql_insert_id(wrapper->client));
 }
 
+/* call-seq:
+ *    client.session_track
+ *
+ * Returns information about changes to the session state on the server.
+ */
+static VALUE rb_mysql_client_session_track(VALUE self, VALUE type) {
+#ifdef CLIENT_SESSION_TRACK
+  const char *data;
+  size_t length;
+  my_ulonglong retVal;
+  GET_CLIENT(self);
+
+  REQUIRE_CONNECTED(wrapper);
+  retVal = mysql_session_track_get_first(wrapper->client, NUM2INT(type), &data, &length);
+  if (retVal != 0) {
+    return Qnil;
+  }
+  VALUE rbAry = rb_ary_new();
+  VALUE rbFirst = rb_str_new(data, length);
+  rb_ary_push(rbAry, rbFirst);
+  while(mysql_session_track_get_next(wrapper->client, NUM2INT(type), &data, &length) == 0) {
+    VALUE rbNext = rb_str_new(data, length);
+    rb_ary_push(rbAry, rbNext);
+  }
+  return rbAry;
+#else
+  return Qnil;
+#endif
+}
+
 /* call-seq:
  *    client.affected_rows
  *
@@ -996,13 +1221,30 @@ static void *nogvl_ping(void *ptr) {
 static VALUE rb_mysql_client_ping(VALUE self) {
   GET_CLIENT(self);
 
-  if (!wrapper->connected) {
+  if (!CONNECTED(wrapper)) {
     return Qfalse;
   } else {
     return (VALUE)rb_thread_call_without_gvl(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
   }
 }
 
+/* call-seq:
+ *    client.set_server_option(value)
+ *
+ * Enables or disables an option for the connection.
+ * Read https://dev.mysql.com/doc/refman/5.7/en/mysql-set-server-option.html
+ * for more information.
+ */
+static VALUE rb_mysql_client_set_server_option(VALUE self, VALUE value) {
+  GET_CLIENT(self);
+
+  if (mysql_set_server_option(wrapper->client, NUM2INT(value)) == 0) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
 /* call-seq:
  *    client.more_results?
  *
@@ -1011,10 +1253,10 @@ static VALUE rb_mysql_client_ping(VALUE self) {
 static VALUE rb_mysql_client_more_results(VALUE self)
 {
   GET_CLIENT(self);
-    if (mysql_more_results(wrapper->client) == 0)
-      return Qfalse;
-    else
-      return Qtrue;
+  if (mysql_more_results(wrapper->client) == 0)
+    return Qfalse;
+  else
+    return Qtrue;
 }
 
 /* call-seq:
@@ -1061,7 +1303,8 @@ static VALUE rb_mysql_client_store_result(VALUE self)
     return Qnil;
   }
 
-  current = rb_hash_dup(rb_iv_get(self, "@current_query_options"));
+  // Duplicate the options hash and put the copy in the Result object
+  current = rb_hash_dup(rb_ivar_get(self, intern_current_query_options));
   (void)RB_GC_GUARD(current);
   Check_Type(current, T_HASH);
   resultObj = rb_mysql_result_to_obj(self, wrapper->encoding, current, result, Qnil);
@@ -1069,7 +1312,6 @@ static VALUE rb_mysql_client_store_result(VALUE self)
   return resultObj;
 }
 
-#ifdef HAVE_RUBY_ENCODING_H
 /* call-seq:
  *    client.encoding
  *
@@ -1079,7 +1321,39 @@ static VALUE rb_mysql_client_encoding(VALUE self) {
   GET_CLIENT(self);
   return wrapper->encoding;
 }
+
+/* call-seq:
+ *    client.automatic_close?
+ *
+ * @return [Boolean]
+ */
+static VALUE get_automatic_close(VALUE self) {
+  GET_CLIENT(self);
+  return wrapper->automatic_close ? Qtrue : Qfalse;
+}
+
+/* call-seq:
+ *    client.automatic_close = false
+ *
+ * Set this to +false+ to leave the connection open after it is garbage
+ * collected. To avoid "Aborted connection" errors on the server, explicitly
+ * call +close+ when the connection is no longer needed.
+ *
+ * @see http://dev.mysql.com/doc/en/communication-errors.html
+ */
+static VALUE set_automatic_close(VALUE self, VALUE value) {
+  GET_CLIENT(self);
+  if (RTEST(value)) {
+    wrapper->automatic_close = 1;
+  } else {
+#ifndef _WIN32
+    wrapper->automatic_close = 0;
+#else
+    rb_warn("Connections are always closed by garbage collector on Windows");
 #endif
+  }
+  return value;
+}
 
 /* call-seq:
  *    client.reconnect = true
@@ -1116,7 +1390,7 @@ static VALUE set_read_timeout(VALUE self, VALUE value) {
   /* Set the instance variable here even though _mysql_client_options
      might not succeed, because the timeout is used in other ways
      elsewhere */
-  rb_iv_set(self, "@read_timeout", value);
+  rb_ivar_set(self, intern_read_timeout, value);
   return _mysql_client_options(self, MYSQL_OPT_READ_TIMEOUT, value);
 }
 
@@ -1132,16 +1406,14 @@ static VALUE set_write_timeout(VALUE self, VALUE value) {
 
 static VALUE set_charset_name(VALUE self, VALUE value) {
   char *charset_name;
-#ifdef HAVE_RUBY_ENCODING_H
   const struct mysql2_mysql_enc_name_to_rb_map *mysql2rb;
   rb_encoding *enc;
   VALUE rb_enc;
-#endif
   GET_CLIENT(self);
 
+  Check_Type(value, T_STRING);
   charset_name = RSTRING_PTR(value);
 
-#ifdef HAVE_RUBY_ENCODING_H
   mysql2rb = mysql2_mysql_enc_name_to_rb(charset_name, (unsigned int)RSTRING_LEN(value));
   if (mysql2rb == NULL || mysql2rb->rb_name == NULL) {
     VALUE inspect = rb_inspect(value);
@@ -1151,7 +1423,6 @@ static VALUE set_charset_name(VALUE self, VALUE value) {
     rb_enc = rb_enc_from_encoding(enc);
     wrapper->encoding = rb_enc;
   }
-#endif
 
   if (mysql_options(wrapper->client, MYSQL_SET_CHARSET_NAME, charset_name)) {
     /* TODO: warning - unable to set charset */
@@ -1175,7 +1446,12 @@ static VALUE set_ssl_options(VALUE self, VALUE key, VALUE cert, VALUE ca, VALUE
 }
 
 static VALUE set_secure_auth(VALUE self, VALUE value) {
+/* This option was deprecated in MySQL 5.x and removed in MySQL 8.0 */
+#ifdef MYSQL_SECURE_AUTH
   return _mysql_client_options(self, MYSQL_SECURE_AUTH, value);
+#else
+  return Qfalse;
+#endif
 }
 
 static VALUE set_read_default_file(VALUE self, VALUE value) {
@@ -1190,12 +1466,28 @@ static VALUE set_init_command(VALUE self, VALUE value) {
   return _mysql_client_options(self, MYSQL_INIT_COMMAND, value);
 }
 
+static VALUE set_default_auth(VALUE self, VALUE value) {
+#ifdef HAVE_MYSQL_DEFAULT_AUTH
+  return _mysql_client_options(self, MYSQL_DEFAULT_AUTH, value);
+#else
+  rb_raise(cMysql2Error, "pluggable authentication is not available, you may need a newer MySQL client library");
+#endif
+}
+
+static VALUE set_enable_cleartext_plugin(VALUE self, VALUE value) {
+#ifdef HAVE_CONST_MYSQL_ENABLE_CLEARTEXT_PLUGIN
+  return _mysql_client_options(self, MYSQL_ENABLE_CLEARTEXT_PLUGIN, value);
+#else
+  rb_raise(cMysql2Error, "enable-cleartext-plugin is not available, you may need a newer MySQL client library");
+#endif
+}
+
 static VALUE initialize_ext(VALUE self) {
   GET_CLIENT(self);
 
   if ((VALUE)rb_thread_call_without_gvl(nogvl_init, wrapper, RUBY_UBF_IO, 0) == Qfalse) {
     /* TODO: warning - not enough memory? */
-    return rb_raise_mysql2_error(wrapper);
+    rb_raise_mysql2_error(wrapper);
   }
 
   wrapper->initialized = 1;
@@ -1243,6 +1535,7 @@ void init_mysql2_client() {
   mMysql2      = rb_define_module("Mysql2"); Teach RDoc about Mysql2 constant.
 #endif
   cMysql2Client = rb_define_class_under(mMysql2, "Client", rb_cObject);
+  rb_global_variable(&cMysql2Client);
 
   rb_define_alloc_func(cMysql2Client, allocate);
 
@@ -1250,6 +1543,7 @@ void init_mysql2_client() {
   rb_define_singleton_method(cMysql2Client, "info", rb_mysql_client_info, 0);
 
   rb_define_method(cMysql2Client, "close", rb_mysql_client_close, 0);
+  rb_define_method(cMysql2Client, "closed?", rb_mysql_client_closed, 0);
   rb_define_method(cMysql2Client, "abandon_results!", rb_mysql_client_abandon_results, 0);
   rb_define_method(cMysql2Client, "escape", rb_mysql_client_real_escape, 1);
   rb_define_method(cMysql2Client, "server_info", rb_mysql_client_server_info, 0);
@@ -1261,15 +1555,18 @@ void init_mysql2_client() {
   rb_define_method(cMysql2Client, "thread_id", rb_mysql_client_thread_id, 0);
   rb_define_method(cMysql2Client, "ping", rb_mysql_client_ping, 0);
   rb_define_method(cMysql2Client, "select_db", rb_mysql_client_select_db, 1);
+  rb_define_method(cMysql2Client, "set_server_option", rb_mysql_client_set_server_option, 1);
   rb_define_method(cMysql2Client, "more_results?", rb_mysql_client_more_results, 0);
   rb_define_method(cMysql2Client, "next_result", rb_mysql_client_next_result, 0);
   rb_define_method(cMysql2Client, "store_result", rb_mysql_client_store_result, 0);
+  rb_define_method(cMysql2Client, "automatic_close?", get_automatic_close, 0);
+  rb_define_method(cMysql2Client, "automatic_close=", set_automatic_close, 1);
   rb_define_method(cMysql2Client, "reconnect=", set_reconnect, 1);
   rb_define_method(cMysql2Client, "warning_count", rb_mysql_client_warning_count, 0);
   rb_define_method(cMysql2Client, "query_info_string", rb_mysql_info, 0);
-#ifdef HAVE_RUBY_ENCODING_H
+  rb_define_method(cMysql2Client, "ssl_cipher", rb_mysql_get_ssl_cipher, 0);
   rb_define_method(cMysql2Client, "encoding", rb_mysql_client_encoding, 0);
-#endif
+  rb_define_method(cMysql2Client, "session_track", rb_mysql_client_session_track, 1);
 
   rb_define_private_method(cMysql2Client, "connect_timeout=", set_connect_timeout, 1);
   rb_define_private_method(cMysql2Client, "read_timeout=", set_read_timeout, 1);
@@ -1280,10 +1577,13 @@ void init_mysql2_client() {
   rb_define_private_method(cMysql2Client, "default_file=", set_read_default_file, 1);
   rb_define_private_method(cMysql2Client, "default_group=", set_read_default_group, 1);
   rb_define_private_method(cMysql2Client, "init_command=", set_init_command, 1);
+  rb_define_private_method(cMysql2Client, "default_auth=", set_default_auth, 1);
   rb_define_private_method(cMysql2Client, "ssl_set", set_ssl_options, 5);
+  rb_define_private_method(cMysql2Client, "ssl_mode=", rb_set_ssl_mode_option, 1);
+  rb_define_private_method(cMysql2Client, "enable_cleartext_plugin=", set_enable_cleartext_plugin, 1);
   rb_define_private_method(cMysql2Client, "initialize_ext", initialize_ext, 0);
-  rb_define_private_method(cMysql2Client, "connect", rb_connect, 7);
-  rb_define_private_method(cMysql2Client, "_query", rb_query, 2);
+  rb_define_private_method(cMysql2Client, "connect", rb_mysql_connect, 8);
+  rb_define_private_method(cMysql2Client, "_query", rb_mysql_query, 2);
 
   sym_id              = ID2SYM(rb_intern("id"));
   sym_version         = ID2SYM(rb_intern("version"));
@@ -1294,14 +1594,24 @@ void init_mysql2_client() {
   sym_array           = ID2SYM(rb_intern("array"));
   sym_stream          = ID2SYM(rb_intern("stream"));
 
+  sym_no_good_index_used = ID2SYM(rb_intern("no_good_index_used"));
+  sym_no_index_used      = ID2SYM(rb_intern("no_index_used"));
+  sym_query_was_slow     = ID2SYM(rb_intern("query_was_slow"));
+
   intern_brackets = rb_intern("[]");
   intern_merge = rb_intern("merge");
   intern_merge_bang = rb_intern("merge!");
   intern_new_with_args = rb_intern("new_with_args");
+  intern_current_query_options = rb_intern("@current_query_options");
+  intern_read_timeout = rb_intern("@read_timeout");
 
 #ifdef CLIENT_LONG_PASSWORD
   rb_const_set(cMysql2Client, rb_intern("LONG_PASSWORD"),
       LONG2NUM(CLIENT_LONG_PASSWORD));
+#else
+  /* HACK because MariaDB 10.2 no longer defines this constant,
+   * but we're using it in our default connection flags. */
+  rb_const_set(cMysql2Client, rb_intern("LONG_PASSWORD"), INT2NUM(0));
 #endif
 
 #ifdef CLIENT_FOUND_ROWS
@@ -1379,6 +1689,16 @@ void init_mysql2_client() {
   rb_const_set(cMysql2Client, rb_intern("SECURE_CONNECTION"), LONG2NUM(0));
 #endif
 
+#ifdef HAVE_CONST_MYSQL_OPTION_MULTI_STATEMENTS_ON
+  rb_const_set(cMysql2Client, rb_intern("OPTION_MULTI_STATEMENTS_ON"),
+      LONG2NUM(MYSQL_OPTION_MULTI_STATEMENTS_ON));
+#endif
+
+#ifdef HAVE_CONST_MYSQL_OPTION_MULTI_STATEMENTS_OFF
+  rb_const_set(cMysql2Client, rb_intern("OPTION_MULTI_STATEMENTS_OFF"),
+      LONG2NUM(MYSQL_OPTION_MULTI_STATEMENTS_OFF));
+#endif
+
 #ifdef CLIENT_MULTI_STATEMENTS
   rb_const_set(cMysql2Client, rb_intern("MULTI_STATEMENTS"),
       LONG2NUM(CLIENT_MULTI_STATEMENTS));
@@ -1408,4 +1728,83 @@ void init_mysql2_client() {
   rb_const_set(cMysql2Client, rb_intern("BASIC_FLAGS"),
       LONG2NUM(CLIENT_BASIC_FLAGS));
 #endif
+
+#ifdef CLIENT_CONNECT_ATTRS
+  rb_const_set(cMysql2Client, rb_intern("CONNECT_ATTRS"),
+      LONG2NUM(CLIENT_CONNECT_ATTRS));
+#else
+  /* HACK because MySQL 5.5 and earlier don't define this constant,
+   * but we're using it in our default connection flags. */
+  rb_const_set(cMysql2Client, rb_intern("CONNECT_ATTRS"),
+      INT2NUM(0));
+#endif
+
+#ifdef CLIENT_SESSION_TRACK
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK"), INT2NUM(CLIENT_SESSION_TRACK));
+  /* From mysql_com.h -- but stable from at least 5.7.4 through 8.0.20 */
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK_SYSTEM_VARIABLES"), INT2NUM(SESSION_TRACK_SYSTEM_VARIABLES));
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK_SCHEMA"), INT2NUM(SESSION_TRACK_SCHEMA));
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK_STATE_CHANGE"), INT2NUM(SESSION_TRACK_STATE_CHANGE));
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK_GTIDS"), INT2NUM(SESSION_TRACK_GTIDS));
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK_TRANSACTION_CHARACTERISTICS"), INT2NUM(SESSION_TRACK_TRANSACTION_CHARACTERISTICS));
+  rb_const_set(cMysql2Client, rb_intern("SESSION_TRACK_TRANSACTION_STATE"), INT2NUM(SESSION_TRACK_TRANSACTION_STATE));
+#endif
+
+#if defined(FULL_SSL_MODE_SUPPORT) // MySQL 5.6.36 and MySQL 5.7.11 and above
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_DISABLED"), INT2NUM(SSL_MODE_DISABLED));
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_PREFERRED"), INT2NUM(SSL_MODE_PREFERRED));
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_REQUIRED"), INT2NUM(SSL_MODE_REQUIRED));
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_VERIFY_CA"), INT2NUM(SSL_MODE_VERIFY_CA));
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_VERIFY_IDENTITY"), INT2NUM(SSL_MODE_VERIFY_IDENTITY));
+#else
+#ifdef HAVE_CONST_MYSQL_OPT_SSL_VERIFY_SERVER_CERT // MySQL 5.7.3 - 5.7.10 & MariaDB 10.x and later
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_VERIFY_IDENTITY"), INT2NUM(SSL_MODE_VERIFY_IDENTITY));
+#endif
+#ifdef HAVE_CONST_MYSQL_OPT_SSL_ENFORCE // MySQL 5.7.3 - 5.7.10 & MariaDB 10.x and later
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_DISABLED"), INT2NUM(SSL_MODE_DISABLED));
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_REQUIRED"), INT2NUM(SSL_MODE_REQUIRED));
+#endif
+#endif
+
+#ifndef HAVE_CONST_SSL_MODE_DISABLED
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_DISABLED"), INT2NUM(0));
+#endif
+#ifndef HAVE_CONST_SSL_MODE_PREFERRED
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_PREFERRED"), INT2NUM(0));
+#endif
+#ifndef HAVE_CONST_SSL_MODE_REQUIRED
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_REQUIRED"), INT2NUM(0));
+#endif
+#ifndef HAVE_CONST_SSL_MODE_VERIFY_CA
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_VERIFY_CA"), INT2NUM(0));
+#endif
+#ifndef HAVE_CONST_SSL_MODE_VERIFY_IDENTITY
+  rb_const_set(cMysql2Client, rb_intern("SSL_MODE_VERIFY_IDENTITY"), INT2NUM(0));
+#endif
+}
+
+#define flag_to_bool(f) ((client->server_status & f) ? Qtrue : Qfalse)
+
+void rb_mysql_set_server_query_flags(MYSQL *client, VALUE result) {
+  VALUE server_flags = rb_hash_new();
+
+#ifdef HAVE_CONST_SERVER_QUERY_NO_GOOD_INDEX_USED
+  rb_hash_aset(server_flags, sym_no_good_index_used, flag_to_bool(SERVER_QUERY_NO_GOOD_INDEX_USED));
+#else
+  rb_hash_aset(server_flags, sym_no_good_index_used, Qnil);
+#endif
+
+#ifdef HAVE_CONST_SERVER_QUERY_NO_INDEX_USED
+  rb_hash_aset(server_flags, sym_no_index_used, flag_to_bool(SERVER_QUERY_NO_INDEX_USED));
+#else
+  rb_hash_aset(server_flags, sym_no_index_used, Qnil);
+#endif
+
+#ifdef HAVE_CONST_SERVER_QUERY_WAS_SLOW
+  rb_hash_aset(server_flags, sym_query_was_slow, flag_to_bool(SERVER_QUERY_WAS_SLOW));
+#else
+  rb_hash_aset(server_flags, sym_query_was_slow, Qnil);
+#endif
+
+  rb_iv_set(result, "@server_flags", server_flags);
 }