mysql2 0.3.11 → 0.3.12b1

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.3.12b1)
+
+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

@@ -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,6 +249,21 @@ 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 or without rails), all you should need to do is have this gem installed and set the adapter in your database.yml to "mysql2".
@@ -326,6 +378,12 @@ 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=");