mysql2 0.2.18 → 0.2.19b1

data/.gitignore

@@ -1,3 +1,4 @@
+bin/
 Makefile
 *.dSYM
 *.o
@@ -10,3 +11,4 @@ pkg/
 tmp
 vendor
 lib/mysql2/mysql2.rb
+spec/configuration.yml

data/.rbenv-version

@@ -0,0 +1 @@
+1.9.3

data/Gemfile.lock

@@ -0,0 +1,61 @@
+PATH
+  remote: .
+  specs:
+    mysql2 (0.2.19b1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.1)
+      activesupport (= 3.2.1)
+      builder (~> 3.0.0)
+    activerecord (3.2.1)
+      activemodel (= 3.2.1)
+      activesupport (= 3.2.1)
+      arel (~> 3.0.0)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.1)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.2.6)
+    arel (3.0.0)
+    builder (3.0.0)
+    data_objects (0.10.8)
+      addressable (~> 2.1)
+    diff-lcs (1.1.3)
+    do_mysql (0.10.8)
+      data_objects (= 0.10.8)
+    eventmachine (0.12.10)
+    faker (1.0.1)
+      i18n (~> 0.4)
+    i18n (0.6.0)
+    multi_json (1.0.4)
+    mysql (2.8.1)
+    rake (0.8.7)
+    rake-compiler (0.7.9)
+      rake
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    sequel (3.32.0)
+    tzinfo (0.3.31)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  do_mysql
+  eventmachine
+  faker
+  mysql
+  mysql2!
+  rake (= 0.8.7)
+  rake-compiler (~> 0.7.7)
+  rspec
+  sequel

data/README.md

@@ -6,7 +6,7 @@ This one is not.
 
 It also forces the use of UTF-8 [or binary] for the connection [and all strings in 1.9, unless Encoding.default_internal is set then it'll convert from UTF-8 to that encoding] and uses encoding-aware MySQL API calls where it can.
 
-The API consists of two clases:
+The API consists of two classes:
 
 Mysql2::Client - your connection to the database
 
@@ -85,6 +85,43 @@ results.each(:as => :array) do |row|
 end
 ```
 
+## Connection options
+
+You may set the following connection options in Mysql2::Client.new(...):
+
+``` ruby
+Mysql2::Client.new(
+  :host,
+  :username,
+  :password,
+  :port,
+  :database,
+  :socket = '/path/to/mysql.sock',
+  :flags = REMEMBER_OPTIONS | LONG_PASSWORD | LONG_FLAG | TRANSACTIONS | PROTOCOL_41 | SECURE_CONNECTION | MULTI_STATEMENTS,
+  :encoding = 'utf8',
+  :read_timeout = seconds,
+  :connect_timeout = seconds,
+  :reconnect = true/false,
+  :local_infile = true/false,
+  )
+```
+
+You can also retrieve multiple result sets. For this to work you need to connect with
+flags `Mysql2::Client::MULTI_STATEMENTS`. Using multiple result sets is normally used
+when calling stored procedures that return more than one result set
+
+``` ruby
+client = Mysql2::Client.new(:host => "localhost", :username => "root", :flags => Mysql2::Client::MULTI_STATEMENTS )
+result = client.query( 'CALL sp_customer_list( 25, 10 )')
+# result now contains the first result set
+while ( client.next_result)
+    result = client.store_result
+    # result now contains the next result set
+end
+```
+
+See https://gist.github.com/1367987 for using MULTI_STATEMENTS with ActiveRecord.
+
 ## Cascading config
 
 The default config hash is at:
@@ -212,9 +249,24 @@ This is especially helpful since it saves the cost of creating the row in Ruby i
 If you only plan on using each row once, then it's much more efficient to disable this behavior by setting the `:cache_rows` option to false.
 This would be helpful if you wanted to iterate over the results in a streaming manner. Meaning the GC would cleanup rows you don't need anymore as you're iterating over the result set.
 
+### Streaming
+
+`Mysql2::Client` can optionally only fetch rows from the server on demand by setting `:stream => true`. This is handy when handling very large result sets which might not fit in memory on the client.
+
+``` ruby
+result = client.query("SELECT * FROM really_big_Table", :stream => true)
+```
+
+There are a few things that need to be kept in mind while using streaming:
+
+* `:cache_rows` is ignored currently. (if you want to use `:cache_rows` you probably don't want to be using `:stream`)
+* You must fetch all rows in the result set of your query before you can make new queries. (i.e. with `Mysql2::Result#each`)
+
+Read more about the consequences of using `mysql_use_result` (what streaming is implemented with) here: http://dev.mysql.com/doc/refman/5.0/en/mysql-use-result.html.
+
 ## ActiveRecord
 
-To use the ActiveRecord driver (with our without rails), all you should need to do is have this gem installed and set the adapter in your database.yml to "mysql2".
+To use the ActiveRecord driver (with or without rails), all you should need to do is have this gem installed and set the adapter in your database.yml to "mysql2".
 That was easy right? :)
 
 NOTE: as of 0.3.0, and ActiveRecord 3.1 - the ActiveRecord adapter has been pulled out of this gem and into ActiveRecord itself. If you need to use mysql2 with
@@ -222,8 +274,7 @@ Rails versions < 3.1 make sure and specify `gem "mysql2", "~> 0.2.7"` in your Ge
 
 ## Asynchronous ActiveRecord
 
-You can also use Mysql2 with asynchronous Rails (first introduced at http://www.mikeperham.com/2010/04/03/introducing-phat-an-asynchronous-rails-app/) by
-setting the adapter in your database.yml to "em_mysql2".  You must be running Ruby 1.9, thin and the rack-fiber_pool middleware for it to work.
+Please see the [em-synchrony](https://github.com/igrigorik/em-synchrony) project for details about using EventMachine with mysql2 and Rails.
 
 ## Sequel
 
@@ -318,6 +369,21 @@ bundle install
 rake
 ```
 
+The tests require the "test" database to exist, and expect to connect
+both as root and the running user, both with a blank password:
+
+``` sql
+CREATE DATABASE test;
+CREATE USER '<user>'@'localhost' IDENTIFIED BY '';
+GRANT ALL PRIVILEGES ON test.* TO '<user>'@'localhost';
+```
+
+You can change these defaults in the spec/configuration.yml which is generated
+automatically when you run rake (or explicitly `rake spec/configuration.yml`).
+
+For a normal installation on a Mac, you most likely do not need to do anything,
+though.
+
 ## Special Thanks
 
 * Eric Wong - for the contribution (and the informative explanations) of some thread-safety, non-blocking I/O and cleanup patches. You rock dude

data/ext/mysql2/client.c

@@ -9,16 +9,28 @@
 VALUE cMysql2Client;
 extern VALUE mMysql2, cMysql2Error;
 static VALUE intern_encoding_from_charset;
-static VALUE sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array;
+static VALUE sym_id, sym_version, sym_async, sym_symbolize_keys, sym_as, sym_array, sym_stream;
 static ID intern_merge, intern_error_number_eql, intern_sql_state_eql;
 
-#define REQUIRE_OPEN_DB(wrapper) \
-  if(!wrapper->reconnect_enabled && wrapper->closed) { \
+#define REQUIRE_INITIALIZED(wrapper) \
+  if (!wrapper->initialized) { \
+    rb_raise(cMysql2Error, "MySQL client is not initialized"); \
+  }
+
+#define REQUIRE_CONNECTED(wrapper) \
+  REQUIRE_INITIALIZED(wrapper) \
+  if (!wrapper->connected && !wrapper->reconnect_enabled) { \
     rb_raise(cMysql2Error, "closed MySQL connection"); \
   }
 
+#define REQUIRE_NOT_CONNECTED(wrapper) \
+  REQUIRE_INITIALIZED(wrapper) \
+  if (wrapper->connected) { \
+    rb_raise(cMysql2Error, "MySQL connection is already open"); \
+  }
+
 #define MARK_CONN_INACTIVE(conn) \
-  wrapper->active = 0
+  wrapper->active_thread = Qnil;
 
 #define GET_CLIENT(self) \
   mysql_client_wrapper *wrapper; \
@@ -51,6 +63,15 @@ struct nogvl_send_query_args {
   mysql_client_wrapper *wrapper;
 };
 
+/*
+ * used to pass all arguments to mysql_select_db while inside
+ * rb_thread_blocking_region
+ */
+struct nogvl_select_db_args {
+  MYSQL *mysql;
+  char *db;
+};
+
 /*
  * non-blocking mysql_*() functions that we won't be wrapping since
  * they do not appear to hit the network nor issue any interruptible
@@ -77,6 +98,7 @@ 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);
   }
 }
 
@@ -128,9 +150,9 @@ static VALUE nogvl_close(void *ptr) {
   int flags;
 #endif
   wrapper = ptr;
-  if (!wrapper->closed) {
-    wrapper->closed = 1;
-    wrapper->active = 0;
+  if (wrapper->connected) {
+    wrapper->active_thread = Qnil;
+    wrapper->connected = 0;
     /*
      * we'll send a QUIT message to the server, but that message is more of a
      * formality than a hard requirement since the socket is getting shutdown
@@ -166,9 +188,10 @@ static VALUE allocate(VALUE klass) {
   mysql_client_wrapper * wrapper;
   obj = Data_Make_Struct(klass, mysql_client_wrapper, rb_mysql_client_mark, rb_mysql_client_free, wrapper);
   wrapper->encoding = Qnil;
-  wrapper->active = 0;
+  wrapper->active_thread = Qnil;
   wrapper->reconnect_enabled = 0;
-  wrapper->closed = 1;
+  wrapper->connected = 0; // means that a database connection is open
+  wrapper->initialized = 0; // means that that the wrapper is initialized
   wrapper->client = (MYSQL*)xmalloc(sizeof(MYSQL));
   return obj;
 }
@@ -214,7 +237,7 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
 
   rv = rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0);
   if (rv == Qfalse) {
-    while (rv == Qfalse && errno == EINTR) {
+    while (rv == Qfalse && errno == EINTR && !mysql_errno(wrapper->client)) {
       errno = 0;
       rv = rb_thread_blocking_region(nogvl_connect, &args, RUBY_UBF_IO, 0);
     }
@@ -222,6 +245,7 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
       return rb_raise_mysql2_error(wrapper);
   }
 
+  wrapper->connected = 1;
   return self;
 }
 
@@ -234,7 +258,7 @@ static VALUE rb_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE po
 static VALUE rb_mysql_client_close(VALUE self) {
   GET_CLIENT(self);
 
-  if (!wrapper->closed) {
+  if (wrapper->connected) {
     rb_thread_blocking_region(nogvl_close, wrapper, RUBY_UBF_IO, 0);
   }
 
@@ -278,21 +302,38 @@ static VALUE nogvl_read_query_result(void *ptr) {
   return res == 0 ? Qtrue : Qfalse;
 }
 
-/* mysql_store_result may (unlikely) read rows off the socket */
-static VALUE nogvl_store_result(void *ptr) {
+static VALUE nogvl_do_result(void *ptr, char use_result) {
   mysql_client_wrapper *wrapper;
   MYSQL_RES *result;
 
   wrapper = (mysql_client_wrapper *)ptr;
-  result = mysql_store_result(wrapper->client);
+  if(use_result) {
+    result = mysql_use_result(wrapper->client);
+  } else {
+    result = mysql_store_result(wrapper->client);
+  }
 
   // once our result is stored off, this connection is
   // ready for another command to be issued
-  wrapper->active = 0;
+  wrapper->active_thread = Qnil;
 
   return (VALUE)result;
 }
 
+/* mysql_store_result may (unlikely) read rows off the socket */
+static VALUE nogvl_store_result(void *ptr) {
+  return nogvl_do_result(ptr, 0);
+}
+
+static VALUE nogvl_use_result(void *ptr) {
+  return nogvl_do_result(ptr, 1);
+}
+
+/* call-seq:
+ *    client.async_result
+ *
+ * Returns the result for the last async issued query.
+ */
 static VALUE rb_mysql_client_async_result(VALUE self) {
   MYSQL_RES * result;
   VALUE resultObj;
@@ -302,17 +343,22 @@ static VALUE rb_mysql_client_async_result(VALUE self) {
   GET_CLIENT(self);
 
   // if we're not waiting on a result, do nothing
-  if (!wrapper->active)
+  if (NIL_P(wrapper->active_thread))
     return Qnil;
 
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   if (rb_thread_blocking_region(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);
   }
 
-  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+  VALUE is_streaming = rb_hash_aref(rb_iv_get(self, "@query_options"), sym_stream);
+  if(is_streaming == Qtrue) {
+    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_use_result, wrapper, RUBY_UBF_IO, 0);
+  } else {
+    result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+  }
 
   if (result == NULL) {
     if (mysql_errno(wrapper->client) != 0) {
@@ -343,8 +389,8 @@ struct async_query_args {
 static VALUE disconnect_and_raise(VALUE self, VALUE error) {
   GET_CLIENT(self);
 
-  wrapper->closed = 1;
-  wrapper->active = 0;
+  wrapper->active_thread = Qnil;
+  wrapper->connected = 0;
 
   // manually close the socket for read/write
   // this feels dirty, but is there another way?
@@ -408,20 +454,26 @@ static VALUE finish_and_mark_inactive(void *args) {
 
   GET_CLIENT(self);
 
-  if (wrapper->active) {
+  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_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
     mysql_free_result(result);
 
-    wrapper->active = 0;
+    wrapper->active_thread = Qnil;
   }
 
   return Qnil;
 }
 #endif
 
+/* call-seq:
+ *    client.query(sql, options = {})
+ *
+ * Query the database with +sql+, with optional +options+.  For the possible
+ * options, see @@default_query_options on the Mysql2::Client class.
+ */
 static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
 #ifndef _WIN32
   struct async_query_args async_args;
@@ -429,12 +481,13 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   struct nogvl_send_query_args args;
   int async = 0;
   VALUE opts, defaults;
+  VALUE thread_current = rb_thread_current();
 #ifdef HAVE_RUBY_ENCODING_H
   rb_encoding *conn_enc;
 #endif
   GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   args.mysql = wrapper->client;
 
 
@@ -460,11 +513,17 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
   args.sql_len = RSTRING_LEN(args.sql);
 
   // see if this connection is still waiting on a result from a previous query
-  if (wrapper->active == 0) {
+  if (NIL_P(wrapper->active_thread)) {
     // mark this connection active
-    wrapper->active = 1;
-  } else {
+    wrapper->active_thread = thread_current;
+  } else if (wrapper->active_thread == thread_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);
+    const char *thr = StringValueCStr(inspect);
+
+    rb_raise(cMysql2Error, "This connection is in use by: %s", thr);
+    RB_GC_GUARD(inspect);
   }
 
   args.wrapper = wrapper;
@@ -490,6 +549,11 @@ static VALUE rb_mysql_client_query(int argc, VALUE * argv, VALUE self) {
 #endif
 }
 
+/* call-seq:
+ *    client.escape(string)
+ *
+ * Escape +string+ so that it may be used in a SQL statement.
+ */
 static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
   unsigned char *newStr;
   VALUE rb_str;
@@ -500,7 +564,7 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
 #endif
   GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   Check_Type(str, T_STRING);
 #ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
@@ -530,6 +594,69 @@ static VALUE rb_mysql_client_real_escape(VALUE self, VALUE str) {
   }
 }
 
+static VALUE _mysql_client_options(VALUE self, int opt, VALUE value) {
+  int result;
+  void *retval = NULL;
+  unsigned int intval = 0;
+  my_bool boolval;
+
+  GET_CLIENT(self);
+
+  REQUIRE_NOT_CONNECTED(wrapper);
+
+  if (NIL_P(value))
+      return Qfalse;
+
+  switch(opt) {
+    case MYSQL_OPT_CONNECT_TIMEOUT:
+      intval = NUM2INT(value);
+      retval = &intval;
+      break;
+
+    case MYSQL_OPT_READ_TIMEOUT:
+      intval = NUM2INT(value);
+      retval = &intval;
+      break;
+
+    case MYSQL_OPT_LOCAL_INFILE:
+      intval = (value == Qfalse ? 0 : 1);
+      retval = &intval;
+      break;
+
+    case MYSQL_OPT_RECONNECT:
+      boolval = (value == Qfalse ? 0 : 1);
+      retval = &boolval;
+      break;
+
+    default:
+      return Qfalse;
+  }
+
+  result = mysql_options(wrapper->client, opt, retval);
+
+  // Zero means success
+  if (result != 0) {
+    rb_warn("%s\n", mysql_error(wrapper->client));
+  } else {
+    // Special case for reconnect, this option is also stored in the wrapper struct
+    if (opt == MYSQL_OPT_RECONNECT)
+      wrapper->reconnect_enabled = boolval;
+  }
+
+  return (result == 0) ? Qtrue : Qfalse;
+}
+
+static VALUE rb_mysql_client_options(VALUE self, VALUE option, VALUE value) {
+  Check_Type(option, T_FIXNUM);
+  int opt = NUM2INT(option);
+  return _mysql_client_options(self, opt, value);
+}
+
+/* call-seq:
+ *    client.info
+ *
+ * Returns a string that represents the client library version.
+ */
 static VALUE rb_mysql_client_info(VALUE self) {
   VALUE version, client_info;
 #ifdef HAVE_RUBY_ENCODING_H
@@ -556,6 +683,11 @@ static VALUE rb_mysql_client_info(VALUE self) {
   return version;
 }
 
+/* call-seq:
+ *    client.server_info
+ *
+ * Returns a string that represents the server version number
+ */
 static VALUE rb_mysql_client_server_info(VALUE self) {
   VALUE version, server_info;
 #ifdef HAVE_RUBY_ENCODING_H
@@ -564,7 +696,7 @@ static VALUE rb_mysql_client_server_info(VALUE self) {
 #endif
   GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
 #ifdef HAVE_RUBY_ENCODING_H
   default_internal_enc = rb_default_internal_encoding();
   conn_enc = rb_to_encoding(wrapper->encoding);
@@ -583,10 +715,15 @@ static VALUE rb_mysql_client_server_info(VALUE self) {
   return version;
 }
 
+/* call-seq:
+ *    client.socket
+ *
+ * Return the file descriptor number for this client.
+ */
 static VALUE rb_mysql_client_socket(VALUE self) {
   GET_CLIENT(self);
 #ifndef _WIN32
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   int fd_set_fd = wrapper->client->net.fd;
   return INT2NUM(fd_set_fd);
 #else
@@ -594,17 +731,29 @@ static VALUE rb_mysql_client_socket(VALUE self) {
 #endif
 }
 
+/* call-seq:
+ *    client.last_id
+ *
+ * Returns the value generated for an AUTO_INCREMENT column by the previous INSERT or UPDATE
+ * statement.
+ */
 static VALUE rb_mysql_client_last_id(VALUE self) {
   GET_CLIENT(self);
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   return ULL2NUM(mysql_insert_id(wrapper->client));
 }
 
+/* call-seq:
+ *    client.affected_rows
+ *
+ * returns the number of rows changed, deleted, or inserted by the last statement
+ * if it was an UPDATE, DELETE, or INSERT.
+ */
 static VALUE rb_mysql_client_affected_rows(VALUE self) {
   my_ulonglong retVal;
   GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   retVal = mysql_affected_rows(wrapper->client);
   if (retVal == (my_ulonglong)-1) {
     rb_raise_mysql2_error(wrapper);
@@ -612,32 +761,139 @@ static VALUE rb_mysql_client_affected_rows(VALUE self) {
   return ULL2NUM(retVal);
 }
 
+/* call-seq:
+ *    client.thread_id
+ *
+ * Returns the thread ID of the current connection.
+ */
 static VALUE rb_mysql_client_thread_id(VALUE self) {
   unsigned long retVal;
   GET_CLIENT(self);
 
-  REQUIRE_OPEN_DB(wrapper);
+  REQUIRE_CONNECTED(wrapper);
   retVal = mysql_thread_id(wrapper->client);
   return ULL2NUM(retVal);
 }
 
+static VALUE nogvl_select_db(void *ptr) {
+  struct nogvl_select_db_args *args = ptr;
+
+  if (mysql_select_db(args->mysql, args->db) == 0)
+    return Qtrue;
+  else
+    return Qfalse;
+}
+
+/* call-seq:
+ *    client.select_db(name)
+ *
+ * Causes the database specified by +name+ to become the default (current)
+ * database on the connection specified by mysql.
+ */
+static VALUE rb_mysql_client_select_db(VALUE self, VALUE db)
+{
+  struct nogvl_select_db_args args;
+
+  GET_CLIENT(self);
+  REQUIRE_CONNECTED(wrapper);
+
+  args.mysql = wrapper->client;
+  args.db = StringValuePtr(db);
+
+  if (rb_thread_blocking_region(nogvl_select_db, &args, RUBY_UBF_IO, 0) == Qfalse)
+    rb_raise_mysql2_error(wrapper); 
+
+  return db;
+}
+
 static VALUE nogvl_ping(void *ptr) {
   MYSQL *client = ptr;
 
   return mysql_ping(client) == 0 ? Qtrue : Qfalse;
 }
 
+/* call-seq:
+ *    client.ping
+ *
+ * Checks whether the connection to the server is working. If the connection
+ * has gone down and auto-reconnect is enabled an attempt to reconnect is made.
+ * If the connection is down and auto-reconnect is disabled, ping returns an
+ * error.
+ */
 static VALUE rb_mysql_client_ping(VALUE self) {
   GET_CLIENT(self);
 
-  if (wrapper->closed) {
+  if (!wrapper->connected) {
     return Qfalse;
   } else {
     return rb_thread_blocking_region(nogvl_ping, wrapper->client, RUBY_UBF_IO, 0);
   }
 }
 
+static VALUE rb_mysql_client_more_results(VALUE self)
+{
+  GET_CLIENT(self);
+    if (mysql_more_results(wrapper->client) == 0)
+      return Qfalse;
+    else
+      return Qtrue;
+}
+
+static VALUE rb_mysql_client_next_result(VALUE self)
+{
+    GET_CLIENT(self);
+    int ret;
+    ret = mysql_next_result(wrapper->client);
+    if (ret == 0)
+      return Qtrue;
+    else
+      return Qfalse;
+}
+
+
+static VALUE rb_mysql_client_store_result(VALUE self)
+{
+  MYSQL_RES * result;
+  VALUE resultObj;
+#ifdef HAVE_RUBY_ENCODING_H
+  mysql2_result_wrapper * result_wrapper;
+#endif
+  
+  
+  GET_CLIENT(self);
+  // MYSQL_RES* res = mysql_store_result(wrapper->client);
+  // if (res == NULL)
+  //    mysql_raise(wrapper->client);
+  // return mysqlres2obj(res);
+  
+  result = (MYSQL_RES *)rb_thread_blocking_region(nogvl_store_result, wrapper, RUBY_UBF_IO, 0);
+
+  if (result == NULL) {
+    if (mysql_errno(wrapper->client) != 0) {
+      rb_raise_mysql2_error(wrapper);
+    }
+    // no data and no error, so query was not a SELECT
+    return Qnil;
+  }
+
+  resultObj = rb_mysql_result_to_obj(result);
+  // pass-through query options for result construction later
+  rb_iv_set(resultObj, "@query_options", rb_funcall(rb_iv_get(self, "@query_options"), rb_intern("dup"), 0));
+
+#ifdef HAVE_RUBY_ENCODING_H
+  GetMysql2Result(resultObj, result_wrapper);
+  result_wrapper->encoding = wrapper->encoding;
+#endif
+  return resultObj;
+  
+}
+
 #ifdef HAVE_RUBY_ENCODING_H
+/* call-seq:
+ *    client.encoding
+ *
+ * Returns the encoding set on the client.
+ */
 static VALUE rb_mysql_client_encoding(VALUE self) {
   GET_CLIENT(self);
   return wrapper->encoding;
@@ -645,37 +901,29 @@ static VALUE rb_mysql_client_encoding(VALUE self) {
 #endif
 
 static VALUE set_reconnect(VALUE self, VALUE value) {
-  my_bool reconnect;
-  GET_CLIENT(self);
-
-  if(!NIL_P(value)) {
-    reconnect = value == Qfalse ? 0 : 1;
+  return _mysql_client_options(self, MYSQL_OPT_RECONNECT, value);
+}
 
-    wrapper->reconnect_enabled = reconnect;
-    /* set default reconnect behavior */
-    if (mysql_options(wrapper->client, MYSQL_OPT_RECONNECT, &reconnect)) {
-      /* TODO: warning - unable to set reconnect behavior */
-      rb_warn("%s\n", mysql_error(wrapper->client));
-    }
-  }
-  return value;
+static VALUE set_local_infile(VALUE self, VALUE value) {
+  return _mysql_client_options(self, MYSQL_OPT_LOCAL_INFILE, value);
 }
 
 static VALUE set_connect_timeout(VALUE self, VALUE value) {
-  unsigned int connect_timeout = 0;
-  GET_CLIENT(self);
-
-  if(!NIL_P(value)) {
-    connect_timeout = NUM2INT(value);
-    if(0 == connect_timeout) return value;
+  return _mysql_client_options(self, MYSQL_OPT_CONNECT_TIMEOUT, value);
+}
 
-    /* set default connection timeout behavior */
-    if (mysql_options(wrapper->client, MYSQL_OPT_CONNECT_TIMEOUT, &connect_timeout)) {
-      /* TODO: warning - unable to set connection timeout */
-      rb_warn("%s\n", mysql_error(wrapper->client));
-    }
+static VALUE set_read_timeout(VALUE self, VALUE value) {
+  long int sec;
+  Check_Type(value, T_FIXNUM);
+  sec = FIX2INT(value);
+  if (sec < 0) {
+    rb_raise(cMysql2Error, "read_timeout must be a positive integer, you passed %ld", sec);
   }
-  return 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);
+  return _mysql_client_options(self, MYSQL_OPT_READ_TIMEOUT, value);
 }
 
 static VALUE set_charset_name(VALUE self, VALUE value) {
@@ -722,7 +970,7 @@ static VALUE set_ssl_options(VALUE self, VALUE key, VALUE cert, VALUE ca, VALUE
   return self;
 }
 
-static VALUE init_connection(VALUE self) {
+static VALUE initialize_ext(VALUE self) {
   GET_CLIENT(self);
 
   if (rb_thread_blocking_region(nogvl_init, wrapper->client, RUBY_UBF_IO, 0) == Qfalse) {
@@ -730,7 +978,7 @@ static VALUE init_connection(VALUE self) {
     return rb_raise_mysql2_error(wrapper);
   }
 
-  wrapper->closed = 0;
+  wrapper->initialized = 1;
   return self;
 }
 
@@ -752,6 +1000,9 @@ void init_mysql2_client() {
     }
   }
 
+#if 0
+  mMysql2      = rb_define_module("Mysql2"); Teach RDoc about Mysql2 constant.
+#endif
   cMysql2Client = rb_define_class_under(mMysql2, "Client", rb_cObject);
 
   rb_define_alloc_func(cMysql2Client, allocate);
@@ -769,15 +1020,22 @@ void init_mysql2_client() {
   rb_define_method(cMysql2Client, "affected_rows", rb_mysql_client_affected_rows, 0);
   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, "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, "options", rb_mysql_client_options, 2);
 #ifdef HAVE_RUBY_ENCODING_H
   rb_define_method(cMysql2Client, "encoding", rb_mysql_client_encoding, 0);
 #endif
 
   rb_define_private_method(cMysql2Client, "reconnect=", set_reconnect, 1);
   rb_define_private_method(cMysql2Client, "connect_timeout=", set_connect_timeout, 1);
+  rb_define_private_method(cMysql2Client, "read_timeout=", set_read_timeout, 1);
+  rb_define_private_method(cMysql2Client, "local_infile=", set_local_infile, 1);
   rb_define_private_method(cMysql2Client, "charset_name=", set_charset_name, 1);
   rb_define_private_method(cMysql2Client, "ssl_set", set_ssl_options, 5);
-  rb_define_private_method(cMysql2Client, "init_connection", init_connection, 0);
+  rb_define_private_method(cMysql2Client, "initialize_ext", initialize_ext, 0);
   rb_define_private_method(cMysql2Client, "connect", rb_connect, 7);
 
   intern_encoding_from_charset = rb_intern("encoding_from_charset");
@@ -788,6 +1046,7 @@ void init_mysql2_client() {
   sym_symbolize_keys  = ID2SYM(rb_intern("symbolize_keys"));
   sym_as              = ID2SYM(rb_intern("as"));
   sym_array           = ID2SYM(rb_intern("array"));
+  sym_stream          = ID2SYM(rb_intern("stream"));
 
   intern_merge = rb_intern("merge");
   intern_error_number_eql = rb_intern("error_number=");