mysql2 0.3.21 → 0.4.1

data/ext/mysql2/client.h

@@ -50,7 +50,27 @@ typedef struct {
   MYSQL *client;
 } mysql_client_wrapper;
 
-void init_mysql2_client();
+#define REQUIRE_CONNECTED(wrapper) \
+  REQUIRE_INITIALIZED(wrapper) \
+  if (!wrapper->connected && !wrapper->reconnect_enabled) { \
+    rb_raise(cMysql2Error, "closed MySQL connection"); \
+  }
+
+void rb_mysql_client_set_active_thread(VALUE self);
+
+#define MARK_CONN_INACTIVE(conn) do {\
+    wrapper->active_thread = Qnil; \
+  } while(0)
+
+#define GET_CLIENT(self) \
+  mysql_client_wrapper *wrapper; \
+  Data_Get_Struct(self, mysql_client_wrapper, wrapper);
+
+void init_mysql2_client(void);
 void decr_mysql2_client(mysql_client_wrapper *wrapper);
 
 #endif
+
+#ifndef HAVE_RB_HASH_DUP
+VALUE rb_hash_dup(VALUE other);
+#endif

data/ext/mysql2/extconf.rb

@@ -1,7 +1,8 @@
 # encoding: UTF-8
 require 'mkmf'
+require 'English'
 
-def asplode lib
+def asplode(lib)
   if RUBY_PLATFORM =~ /mingw|mswin/
     abort "-----\n#{lib} is missing. Check your installation of MySQL or Connector/C, and try again.\n-----"
   elsif RUBY_PLATFORM =~ /darwin/
@@ -22,7 +23,7 @@ have_func('rb_intern3')
 
 # borrowed from mysqlplus
 # http://github.com/oldmoe/mysqlplus/blob/master/ext/extconf.rb
-dirs = ENV['PATH'].split(File::PATH_SEPARATOR) + %w[
+dirs = ENV.fetch('PATH').split(File::PATH_SEPARATOR) + %w(
   /opt
   /opt/local
   /opt/local/mysql
@@ -33,13 +34,15 @@ dirs = ENV['PATH'].split(File::PATH_SEPARATOR) + %w[
   /usr/local/mysql
   /usr/local/mysql-*
   /usr/local/lib/mysql5*
-].map{|dir| "#{dir}/bin" }
+  /usr/local/opt/mysql5*
+).map { |dir| dir << '/bin' }
 
 GLOB = "{#{dirs.join(',')}}/{mysql_config,mysql_config5,mariadb_config}"
 
 # If the user has provided a --with-mysql-dir argument, we must respect it or fail.
 inc, lib = dir_config('mysql')
 if inc && lib
+  # TODO: Remove when 2.0.0 is the minimum supported version
   # Ruby versions not incorporating the mkmf fix at
   # https://bugs.ruby-lang.org/projects/ruby-trunk/repository/revisions/39717
   # do not properly search for lib directories, and must be corrected
@@ -47,48 +50,33 @@ if inc && lib
     @libdir_basename = 'lib'
     inc, lib = dir_config('mysql')
   end
-  abort "-----\nCannot find include dir(s) #{inc}\n-----" unless inc && inc.split(File::PATH_SEPARATOR).any?{|dir| File.directory?(dir)}
-  abort "-----\nCannot find library dir(s) #{lib}\n-----" unless lib && lib.split(File::PATH_SEPARATOR).any?{|dir| File.directory?(dir)}
-  warn  "-----\nUsing --with-mysql-dir=#{File.dirname inc}\n-----"
+  abort "-----\nCannot find include dir(s) #{inc}\n-----" unless inc && inc.split(File::PATH_SEPARATOR).any? { |dir| File.directory?(dir) }
+  abort "-----\nCannot find library dir(s) #{lib}\n-----" unless lib && lib.split(File::PATH_SEPARATOR).any? { |dir| File.directory?(dir) }
+  warn "-----\nUsing --with-mysql-dir=#{File.dirname inc}\n-----"
   rpath_dir = lib
-elsif mc = (with_config('mysql-config') || Dir[GLOB].first)
+elsif (mc = (with_config('mysql-config') || Dir[GLOB].first))
   # If the user has provided a --with-mysql-config argument, we must respect it or fail.
   # If the user gave --with-mysql-config with no argument means we should try to find it.
   mc = Dir[GLOB].first if mc == true
-  abort "-----\nCannot find mysql_config at #{mc}\n-----" unless mc && File.exists?(mc)
+  abort "-----\nCannot find mysql_config at #{mc}\n-----" unless mc && File.exist?(mc)
   abort "-----\nCannot execute mysql_config at #{mc}\n-----" unless File.executable?(mc)
-  warn  "-----\nUsing mysql_config at #{mc}\n-----"
+  warn "-----\nUsing mysql_config at #{mc}\n-----"
   ver = `#{mc} --version`.chomp.to_f
   includes = `#{mc} --include`.chomp
-  exit 1 if $? != 0
+  abort unless $CHILD_STATUS.success?
   libs = `#{mc} --libs_r`.chomp
   # MySQL 5.5 and above already have re-entrant code in libmysqlclient (no _r).
-  if ver >= 5.5 || libs.empty?
-    libs = `#{mc} --libs`.chomp
-  end
-  exit 1 if $? != 0
+  libs = `#{mc} --libs`.chomp if ver >= 5.5 || libs.empty?
+  abort unless $CHILD_STATUS.success?
   $INCFLAGS += ' ' + includes
   $libs = libs + " " + $libs
   rpath_dir = libs
 else
-  inc, lib = dir_config('mysql', '/usr/local')
-  unless find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql")
-    found = false
-    # For some systems and some versions of libmysqlclient, there were extra
-    # libraries needed to link. Try each typical extra library, add it to the
-    # global compile flags, and see if that allows us to link libmysqlclient.
-    warn "-----\nlibmysqlclient is missing. Trying again with extra runtime libraries...\n-----"
-
-    %w{ m z socket nsl mygcc }.each do |extra_lib|
-      if have_library(extra_lib) && find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql")
-        found = true
-        break
-      end
-    end
-    asplode('libmysqlclient') unless found
-  end
+  _, usr_local_lib = dir_config('mysql', '/usr/local')
 
-  rpath_dir = lib
+  asplode("mysql client") unless find_library('mysqlclient', 'mysql_query', usr_local_lib, "#{usr_local_lib}/mysql")
+
+  rpath_dir = usr_local_lib
 end
 
 if have_header('mysql.h')
@@ -99,18 +87,49 @@ else
   asplode 'mysql.h'
 end
 
-%w{ errmsg.h mysqld_error.h }.each do |h|
+%w(errmsg.h mysqld_error.h).each do |h|
   header = [prefix, h].compact.join '/'
-  asplode h unless have_header h
+  asplode h unless have_header header
+end
+
+# This is our wishlist. We use whichever flags work on the host.
+# -Wall and -Wextra are included by default.
+wishlist = [
+  '-Weverything',
+  '-Wno-bad-function-cast', # rb_thread_call_without_gvl returns void * that we cast to VALUE
+  '-Wno-conditional-uninitialized', # false positive in client.c
+  '-Wno-covered-switch-default', # result.c -- enum_field_types (when fully covered, e.g. mysql 5.5)
+  '-Wno-declaration-after-statement', # GET_CLIENT followed by GET_STATEMENT in statement.c
+  '-Wno-disabled-macro-expansion', # rubby :(
+  '-Wno-documentation-unknown-command', # rubby :(
+  '-Wno-missing-field-initializers', # gperf generates bad code
+  '-Wno-missing-variable-declarations', # missing symbols due to ruby native ext initialization
+  '-Wno-padded', # mysql :(
+  '-Wno-sign-conversion', # gperf generates bad code
+  '-Wno-static-in-inline', # gperf generates bad code
+  '-Wno-switch-enum', # result.c -- enum_field_types (when not fully covered, e.g. mysql 5.6+)
+  '-Wno-undef', # rubinius :(
+  '-Wno-used-but-marked-unused', # rubby :(
+]
+
+if ENV['CI']
+  wishlist += [
+    '-Werror',
+    '-fsanitize=address',
+    '-fsanitize=cfi',
+    '-fsanitize=integer',
+    '-fsanitize=memory',
+    '-fsanitize=thread',
+    '-fsanitize=undefined',
+  ]
 end
 
-# These gcc style flags are also supported by clang and xcode compilers,
-# so we'll use a does-it-work test instead of an is-it-gcc test.
-gcc_flags = ' -Wall -funroll-loops'
-if try_link('int main() {return 0;}', gcc_flags)
-  $CFLAGS << gcc_flags
+usable_flags = wishlist.select do |flag|
+  try_link('int main() {return 0;}', flag)
 end
 
+$CFLAGS << ' ' << usable_flags.join(' ')
+
 if RUBY_PLATFORM =~ /mswin|mingw/
   # Build libmysql.a interface link library
   require 'rake'
@@ -119,7 +138,7 @@ if RUBY_PLATFORM =~ /mswin|mingw/
   # Use rake to rebuild only if these files change
   deffile = File.expand_path('../../../support/libmysql.def', __FILE__)
   libfile = File.expand_path(File.join(rpath_dir, 'libmysql.lib'))
-  file 'libmysql.a' => [deffile, libfile] do |t|
+  file 'libmysql.a' => [deffile, libfile] do
     when_writing 'building libmysql.a' do
       # Ruby kindly shows us where dllwrap is, but that tool does more than we want.
       # Maybe in the future Ruby could provide RbConfig::CONFIG['DLLTOOL'] directly.
@@ -146,7 +165,7 @@ if RUBY_PLATFORM =~ /mswin|mingw/
 
   vendordll = File.join(vendordir, 'libmysql.dll')
   dllfile = File.expand_path(File.join(rpath_dir, 'libmysql.dll'))
-  file vendordll => [dllfile, vendordir] do |t|
+  file vendordll => [dllfile, vendordir] do
     when_writing 'copying libmysql.dll' do
       cp dllfile, vendordll
     end
@@ -172,7 +191,7 @@ else
     warn "-----\nSetting mysql rpath to #{explicit_rpath}\n-----"
     $LDFLAGS << rpath_flags
   else
-    if libdir = rpath_dir[%r{(-L)?(/[^ ]+)}, 2]
+    if (libdir = rpath_dir[%r{(-L)?(/[^ ]+)}, 2])
       rpath_flags = " -Wl,-rpath,#{libdir}"
       if RbConfig::CONFIG["RPATHFLAG"].to_s.empty? && try_link('int main() {return 0;}', rpath_flags)
         # Usually Ruby sets RPATHFLAG the right way for each system, but not on OS X.

data/ext/mysql2/infile.c

@@ -56,7 +56,7 @@ mysql2_local_infile_init(void **ptr, const char *filename, void *userdata)
  * < 0   error
  */
 static int
-mysql2_local_infile_read(void *ptr, char *buf, uint buf_len)
+mysql2_local_infile_read(void *ptr, char *buf, unsigned int buf_len)
 {
   int count;
   mysql2_local_infile_data *data = (mysql2_local_infile_data *)ptr;
@@ -95,7 +95,7 @@ mysql2_local_infile_end(void *ptr)
  * Error message number (see http://dev.mysql.com/doc/refman/5.0/en/error-messages-client.html)
  */
 static int
-mysql2_local_infile_error(void *ptr, char *error_msg, uint error_msg_len)
+mysql2_local_infile_error(void *ptr, char *error_msg, unsigned int error_msg_len)
 {
   mysql2_local_infile_data *data = (mysql2_local_infile_data *) ptr;
 

data/ext/mysql2/mysql2_ext.c

@@ -9,4 +9,5 @@ void Init_mysql2() {
 
   init_mysql2_client();
   init_mysql2_result();
+  init_mysql2_statement();
 }

data/ext/mysql2/mysql2_ext.h

@@ -1,18 +1,14 @@
 #ifndef MYSQL2_EXT
 #define MYSQL2_EXT
 
+void Init_mysql2(void);
+
 /* tell rbx not to use it's caching compat layer
    by doing this we're making a promise to RBX that
    we'll never modify the pointers we get back from RSTRING_PTR */
 #define RSTRING_NOT_MODIFIED
 #include <ruby.h>
 
-#ifndef HAVE_UINT
-#define HAVE_UINT
-typedef unsigned short    ushort;
-typedef unsigned int    uint;
-#endif
-
 #ifdef HAVE_MYSQL_H
 #include <mysql.h>
 #include <mysql_com.h>
@@ -33,12 +29,15 @@ typedef unsigned int    uint;
 #endif
 
 #if defined(__GNUC__) && (__GNUC__ >= 3)
+#define RB_MYSQL_NORETURN __attribute__ ((noreturn))
 #define RB_MYSQL_UNUSED __attribute__ ((unused))
 #else
+#define RB_MYSQL_NORETURN
 #define RB_MYSQL_UNUSED
 #endif
 
 #include <client.h>
+#include <statement.h>
 #include <result.h>
 #include <infile.h>
 

data/ext/mysql2/mysql_enc_name_to_ruby.h

@@ -1,4 +1,4 @@
-/* C code produced by gperf version 3.0.3 */
+/* C code produced by gperf version 3.0.4 */
 /* Command-line: gperf  */
 /* Computed positions: -k'1,3,$' */
 
@@ -78,7 +78,7 @@ mysql2_mysql_enc_name_to_rb_hash (str, len)
 
 #ifdef __GNUC__
 __inline
-#ifdef __GNUC_STDC_INLINE__
+#if defined __GNUC_STDC_INLINE__ || defined __GNUC_GNU_INLINE__
 __attribute__ ((__gnu_inline__))
 #endif
 #endif

data/ext/mysql2/mysql_enc_to_ruby.h

@@ -1,4 +1,4 @@
-const char *mysql2_mysql_enc_to_rb[] = {
+static const char *mysql2_mysql_enc_to_rb[] = {
   "Big5",
   "ISO-8859-2",
   NULL,
@@ -54,13 +54,13 @@ const char *mysql2_mysql_enc_to_rb[] = {
   "macRoman",
   "UTF-16",
   "UTF-16",
-  NULL,
+  "",
   "Windows-1256",
   "Windows-1257",
   "Windows-1257",
   "UTF-32",
   "UTF-32",
-  NULL,
+  "",
   "ASCII-8BIT",
   NULL,
   "US-ASCII",
@@ -119,10 +119,10 @@ const char *mysql2_mysql_enc_to_rb[] = {
   "UTF-16",
   "UTF-16",
   "UTF-16",
-  NULL,
-  NULL,
-  NULL,
-  NULL,
+  "UTF-16",
+  "UTF-16",
+  "UTF-16",
+  "UTF-16",
   NULL,
   NULL,
   NULL,
@@ -146,6 +146,10 @@ const char *mysql2_mysql_enc_to_rb[] = {
   "UTF-16BE",
   "UTF-16BE",
   "UTF-16BE",
+  "UTF-16BE",
+  "UTF-16BE",
+  "UTF-16BE",
+  "UTF-16BE",
   NULL,
   NULL,
   NULL,
@@ -153,11 +157,11 @@ const char *mysql2_mysql_enc_to_rb[] = {
   NULL,
   NULL,
   NULL,
-  NULL,
-  NULL,
-  NULL,
-  NULL,
-  NULL,
+  "UTF-16BE",
+  "UTF-32",
+  "UTF-32",
+  "UTF-32",
+  "UTF-32",
   "UTF-32",
   "UTF-32",
   "UTF-32",
@@ -178,10 +182,6 @@ const char *mysql2_mysql_enc_to_rb[] = {
   "UTF-32",
   "UTF-32",
   "UTF-32",
-  NULL,
-  NULL,
-  NULL,
-  NULL,
   NULL,
   NULL,
   NULL,
@@ -210,6 +210,10 @@ const char *mysql2_mysql_enc_to_rb[] = {
   "UTF-8",
   "UTF-8",
   "UTF-8",
+  "UTF-8",
+  "UTF-8",
+  "UTF-8",
+  "UTF-8",
   NULL,
   NULL,
   NULL,
@@ -217,11 +221,11 @@ const char *mysql2_mysql_enc_to_rb[] = {
   NULL,
   NULL,
   NULL,
-  NULL,
-  NULL,
-  NULL,
-  NULL,
-  NULL,
+  "UTF-8",
+  "UTF-8",
+  "UTF-8",
+  "UTF-8",
+  "UTF-8",
   "UTF-8",
   "UTF-8",
   "UTF-8",
@@ -243,4 +247,3 @@ const char *mysql2_mysql_enc_to_rb[] = {
   "UTF-8",
   "UTF-8"
 };
-

data/ext/mysql2/result.c

@@ -1,7 +1,5 @@
 #include <mysql2_ext.h>
 
-#include <stdint.h>
-
 #include "mysql_enc_to_ruby.h"
 
 #ifdef HAVE_RUBY_ENCODING_H
@@ -54,8 +52,20 @@ static rb_encoding *binaryEncoding;
   mysql2_result_wrapper *wrapper; \
   Data_Get_Struct(self, mysql2_result_wrapper, wrapper);
 
+typedef struct {
+  int symbolizeKeys;
+  int asArray;
+  int castBool;
+  int cacheRows;
+  int cast;
+  int streaming;
+  ID db_timezone;
+  ID app_timezone;
+  VALUE block_given;
+} result_each_args;
+
+VALUE cBigDecimal, cDateTime, cDate;
 static VALUE cMysql2Result;
-static VALUE cBigDecimal, cDate, cDateTime;
 static VALUE opt_decimal_zero, opt_float_zero, opt_time_year, opt_time_month, opt_utc_offset;
 extern VALUE mMysql2, cMysql2Client, cMysql2Error;
 static ID intern_new, intern_utc, intern_local, intern_localtime, intern_local_offset, intern_civil, intern_new_offset;
@@ -63,6 +73,7 @@ static VALUE sym_symbolize_keys, sym_as, sym_array, sym_database_timezone, sym_a
           sym_local, sym_utc, sym_cast_booleans, sym_cache_rows, sym_cast, sym_stream, sym_name;
 static ID intern_merge;
 
+/* Mark any VALUEs that are only referenced in C, so the GC won't get them. */
 static void rb_mysql_result_mark(void * wrapper) {
   mysql2_result_wrapper * w = wrapper;
   if (w) {
@@ -70,13 +81,44 @@ static void rb_mysql_result_mark(void * wrapper) {
     rb_gc_mark(w->rows);
     rb_gc_mark(w->encoding);
     rb_gc_mark(w->client);
+    rb_gc_mark(w->statement);
   }
 }
 
 /* this may be called manually or during GC */
 static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
-  if (wrapper && wrapper->resultFreed != 1) {
+  if (!wrapper) return;
+
+  if (wrapper->resultFreed != 1) {
+    if (wrapper->stmt_wrapper) {
+      mysql_stmt_free_result(wrapper->stmt_wrapper->stmt);
+
+      /* MySQL BUG? If the statement handle was previously used, and so
+       * mysql_stmt_bind_result was called, and if that result set and bind buffers were freed,
+       * MySQL still thinks the result set buffer is available and will prefetch the
+       * first result in mysql_stmt_execute. This will corrupt or crash the program.
+       * By setting bind_result_done back to 0, we make MySQL think that a result set
+       * has never been bound to this statement handle before to prevent the prefetch.
+       */
+      wrapper->stmt_wrapper->stmt->bind_result_done = 0;
+
+      if (wrapper->result_buffers) {
+        unsigned int i;
+        for (i = 0; i < wrapper->numberOfFields; i++) {
+          if (wrapper->result_buffers[i].buffer) {
+            xfree(wrapper->result_buffers[i].buffer);
+          }
+        }
+        xfree(wrapper->result_buffers);
+        xfree(wrapper->is_null);
+        xfree(wrapper->error);
+        xfree(wrapper->length);
+      }
+      /* Clue that the next statement execute will need to allocate a new result buffer. */
+      wrapper->result_buffers = NULL;
+    }
     /* FIXME: this may call flush_use_result, which can hit the socket */
+    /* For prepared statements, wrapper->result is the result metadata */
     mysql_free_result(wrapper->result);
     wrapper->resultFreed = 1;
   }
@@ -84,7 +126,7 @@ static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
 
 /* this is called during GC */
 static void rb_mysql_result_free(void *ptr) {
-  mysql2_result_wrapper * wrapper = ptr;
+  mysql2_result_wrapper *wrapper = ptr;
   rb_mysql_result_free_result(wrapper);
 
   // If the GC gets to client first it will be nil
@@ -92,6 +134,10 @@ static void rb_mysql_result_free(void *ptr) {
     decr_mysql2_client(wrapper->client_wrapper);
   }
 
+  if (wrapper->statement != Qnil) {
+    decr_mysql2_stmt(wrapper->stmt_wrapper);
+  }
+
   xfree(wrapper);
 }
 
@@ -106,7 +152,14 @@ static void *nogvl_fetch_row(void *ptr) {
   return mysql_fetch_row(result);
 }
 
-static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int symbolize_keys) {
+static void *nogvl_stmt_fetch(void *ptr) {
+  MYSQL_STMT *stmt = ptr;
+  uintptr_t r = mysql_stmt_fetch(stmt);
+
+  return (void *)r;
+}
+
+static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbolize_keys) {
   VALUE rb_field;
   GET_RESULT(self);
 
@@ -185,7 +238,7 @@ static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_e
  */
 static unsigned int msec_char_to_uint(char *msec_char, size_t len)
 {
-  int i;
+  size_t i;
   for (i = 0; i < (len - 1); i++) {
     if (msec_char[i] == '\0') {
       msec_char[i] = '0';
@@ -194,7 +247,274 @@ static unsigned int msec_char_to_uint(char *msec_char, size_t len)
   return (unsigned int)strtoul(msec_char, NULL, 10);
 }
 
-static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezone, int symbolizeKeys, int asArray, int castBool, int cast, MYSQL_FIELD * fields) {
+static void rb_mysql_result_alloc_result_buffers(VALUE self, MYSQL_FIELD *fields) {
+  unsigned int i;
+  GET_RESULT(self);
+
+  if (wrapper->result_buffers != NULL) return;
+
+  wrapper->result_buffers = xcalloc(wrapper->numberOfFields, sizeof(MYSQL_BIND));
+  wrapper->is_null = xcalloc(wrapper->numberOfFields, sizeof(my_bool));
+  wrapper->error = xcalloc(wrapper->numberOfFields, sizeof(my_bool));
+  wrapper->length = xcalloc(wrapper->numberOfFields, sizeof(unsigned long));
+
+  for (i = 0; i < wrapper->numberOfFields; i++) {
+    wrapper->result_buffers[i].buffer_type = fields[i].type;
+
+    //      mysql type    |            C type
+    switch(fields[i].type) {
+      case MYSQL_TYPE_NULL:         // NULL
+        break;
+      case MYSQL_TYPE_TINY:         // signed char
+        wrapper->result_buffers[i].buffer = xcalloc(1, sizeof(signed char));
+        wrapper->result_buffers[i].buffer_length = sizeof(signed char);
+        break;
+      case MYSQL_TYPE_SHORT:        // short int
+        wrapper->result_buffers[i].buffer = xcalloc(1, sizeof(short int));
+        wrapper->result_buffers[i].buffer_length = sizeof(short int);
+        break;
+      case MYSQL_TYPE_INT24:        // int
+      case MYSQL_TYPE_LONG:         // int
+      case MYSQL_TYPE_YEAR:         // int
+        wrapper->result_buffers[i].buffer = xcalloc(1, sizeof(int));
+        wrapper->result_buffers[i].buffer_length = sizeof(int);
+        break;
+      case MYSQL_TYPE_LONGLONG:     // long long int
+        wrapper->result_buffers[i].buffer = xcalloc(1, sizeof(long long int));
+        wrapper->result_buffers[i].buffer_length = sizeof(long long int);
+        break;
+      case MYSQL_TYPE_FLOAT:        // float
+      case MYSQL_TYPE_DOUBLE:       // double
+        wrapper->result_buffers[i].buffer = xcalloc(1, sizeof(double));
+        wrapper->result_buffers[i].buffer_length = sizeof(double);
+        break;
+      case MYSQL_TYPE_TIME:         // MYSQL_TIME
+      case MYSQL_TYPE_DATE:         // MYSQL_TIME
+      case MYSQL_TYPE_NEWDATE:      // MYSQL_TIME
+      case MYSQL_TYPE_DATETIME:     // MYSQL_TIME
+      case MYSQL_TYPE_TIMESTAMP:    // MYSQL_TIME
+        wrapper->result_buffers[i].buffer = xcalloc(1, sizeof(MYSQL_TIME));
+        wrapper->result_buffers[i].buffer_length = sizeof(MYSQL_TIME);
+        break;
+      case MYSQL_TYPE_DECIMAL:      // char[]
+      case MYSQL_TYPE_NEWDECIMAL:   // char[]
+      case MYSQL_TYPE_STRING:       // char[]
+      case MYSQL_TYPE_VAR_STRING:   // char[]
+      case MYSQL_TYPE_VARCHAR:      // char[]
+      case MYSQL_TYPE_TINY_BLOB:    // char[]
+      case MYSQL_TYPE_BLOB:         // char[]
+      case MYSQL_TYPE_MEDIUM_BLOB:  // char[]
+      case MYSQL_TYPE_LONG_BLOB:    // char[]
+      case MYSQL_TYPE_BIT:          // char[]
+      case MYSQL_TYPE_SET:          // char[]
+      case MYSQL_TYPE_ENUM:         // char[]
+      case MYSQL_TYPE_GEOMETRY:     // char[]
+        wrapper->result_buffers[i].buffer = xmalloc(fields[i].max_length);
+        wrapper->result_buffers[i].buffer_length = fields[i].max_length;
+        break;
+      default:
+        rb_raise(cMysql2Error, "unhandled mysql type: %d", fields[i].type);
+    }
+
+    wrapper->result_buffers[i].is_null = &wrapper->is_null[i];
+    wrapper->result_buffers[i].length  = &wrapper->length[i];
+    wrapper->result_buffers[i].error   = &wrapper->error[i];
+    wrapper->result_buffers[i].is_unsigned = ((fields[i].flags & UNSIGNED_FLAG) != 0);
+  }
+}
+
+static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, const result_each_args *args)
+{
+  VALUE rowVal;
+  unsigned int i = 0;
+
+#ifdef HAVE_RUBY_ENCODING_H
+  rb_encoding *default_internal_enc;
+  rb_encoding *conn_enc;
+#endif
+  GET_RESULT(self);
+
+#ifdef HAVE_RUBY_ENCODING_H
+  default_internal_enc = rb_default_internal_encoding();
+  conn_enc = rb_to_encoding(wrapper->encoding);
+#endif
+
+  if (args->asArray) {
+    rowVal = rb_ary_new2(wrapper->numberOfFields);
+  } else {
+    rowVal = rb_hash_new();
+  }
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
+
+  if (wrapper->result_buffers == NULL) {
+    rb_mysql_result_alloc_result_buffers(self, fields);
+  }
+
+  if (mysql_stmt_bind_result(wrapper->stmt_wrapper->stmt, wrapper->result_buffers)) {
+    rb_raise_mysql2_stmt_error(wrapper->stmt_wrapper);
+  }
+
+  {
+    switch((uintptr_t)rb_thread_call_without_gvl(nogvl_stmt_fetch, wrapper->stmt_wrapper->stmt, RUBY_UBF_IO, 0)) {
+      case 0:
+        /* success */
+        break;
+
+      case 1:
+        /* error */
+        rb_raise_mysql2_stmt_error(wrapper->stmt_wrapper);
+
+      case MYSQL_NO_DATA:
+        /* no more row */
+        return Qnil;
+
+      case MYSQL_DATA_TRUNCATED:
+        rb_raise(cMysql2Error, "IMPLBUG: caught MYSQL_DATA_TRUNCATED. should not come here as buffer_length is set to fields[i].max_length.");
+    }
+  }
+
+  for (i = 0; i < wrapper->numberOfFields; i++) {
+    VALUE field = rb_mysql_result_fetch_field(self, i, args->symbolizeKeys);
+    VALUE val = Qnil;
+    MYSQL_TIME *ts;
+
+    if (wrapper->is_null[i]) {
+      val = Qnil;
+    } else {
+      const MYSQL_BIND* const result_buffer = &wrapper->result_buffers[i];
+
+      switch(result_buffer->buffer_type) {
+        case MYSQL_TYPE_TINY:         // signed char
+          if (args->castBool && fields[i].length == 1) {
+            val = (*((unsigned char*)result_buffer->buffer) != 0) ? Qtrue : Qfalse;
+            break;
+          }
+          if (result_buffer->is_unsigned) {
+            val = UINT2NUM(*((unsigned char*)result_buffer->buffer));
+          } else {
+            val = INT2NUM(*((signed char*)result_buffer->buffer));
+          }
+          break;
+        case MYSQL_TYPE_SHORT:        // short int
+          if (result_buffer->is_unsigned) {
+            val = UINT2NUM(*((unsigned short int*)result_buffer->buffer));
+          } else  {
+            val = INT2NUM(*((short int*)result_buffer->buffer));
+          }
+          break;
+        case MYSQL_TYPE_INT24:        // int
+        case MYSQL_TYPE_LONG:         // int
+        case MYSQL_TYPE_YEAR:         // int
+          if (result_buffer->is_unsigned) {
+            val = UINT2NUM(*((unsigned int*)result_buffer->buffer));
+          } else {
+            val = INT2NUM(*((int*)result_buffer->buffer));
+          }
+          break;
+        case MYSQL_TYPE_LONGLONG:     // long long int
+          if (result_buffer->is_unsigned) {
+            val = ULL2NUM(*((unsigned long long int*)result_buffer->buffer));
+          } else {
+            val = LL2NUM(*((long long int*)result_buffer->buffer));
+          }
+          break;
+        case MYSQL_TYPE_FLOAT:        // float
+          val = rb_float_new((double)(*((float*)result_buffer->buffer)));
+          break;
+        case MYSQL_TYPE_DOUBLE:       // double
+          val = rb_float_new((double)(*((double*)result_buffer->buffer)));
+          break;
+        case MYSQL_TYPE_DATE:         // MYSQL_TIME
+        case MYSQL_TYPE_NEWDATE:      // MYSQL_TIME
+          ts = (MYSQL_TIME*)result_buffer->buffer;
+          val = rb_funcall(cDate, intern_new, 3, INT2NUM(ts->year), INT2NUM(ts->month), INT2NUM(ts->day));
+          break;
+        case MYSQL_TYPE_TIME:         // MYSQL_TIME
+          ts = (MYSQL_TIME*)result_buffer->buffer;
+          val = rb_funcall(rb_cTime, args->db_timezone, 7, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second), ULONG2NUM(ts->second_part));
+          if (!NIL_P(args->app_timezone)) {
+            if (args->app_timezone == intern_local) {
+              val = rb_funcall(val, intern_localtime, 0);
+            } else { // utc
+              val = rb_funcall(val, intern_utc, 0);
+            }
+          }
+          break;
+        case MYSQL_TYPE_DATETIME:     // MYSQL_TIME
+        case MYSQL_TYPE_TIMESTAMP: {  // MYSQL_TIME
+          uint64_t seconds;
+
+          ts = (MYSQL_TIME*)result_buffer->buffer;
+          seconds = (ts->year*31557600ULL) + (ts->month*2592000ULL) + (ts->day*86400ULL) + (ts->hour*3600ULL) + (ts->minute*60ULL) + ts->second;
+
+          if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { // use DateTime instead
+            VALUE offset = INT2NUM(0);
+            if (args->db_timezone == intern_local) {
+              offset = rb_funcall(cMysql2Client, intern_local_offset, 0);
+            }
+            val = rb_funcall(cDateTime, intern_civil, 7, UINT2NUM(ts->year), UINT2NUM(ts->month), UINT2NUM(ts->day), UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second), offset);
+            if (!NIL_P(args->app_timezone)) {
+              if (args->app_timezone == intern_local) {
+                offset = rb_funcall(cMysql2Client, intern_local_offset, 0);
+                val = rb_funcall(val, intern_new_offset, 1, offset);
+              } else { // utc
+                val = rb_funcall(val, intern_new_offset, 1, opt_utc_offset);
+              }
+            }
+          } else {
+            val = rb_funcall(rb_cTime, args->db_timezone, 7, UINT2NUM(ts->year), UINT2NUM(ts->month), UINT2NUM(ts->day), UINT2NUM(ts->hour), UINT2NUM(ts->minute), UINT2NUM(ts->second), ULONG2NUM(ts->second_part));
+            if (!NIL_P(args->app_timezone)) {
+              if (args->app_timezone == intern_local) {
+                val = rb_funcall(val, intern_localtime, 0);
+              } else { // utc
+                val = rb_funcall(val, intern_utc, 0);
+              }
+            }
+          }
+          break;
+        }
+        case MYSQL_TYPE_DECIMAL:      // char[]
+        case MYSQL_TYPE_NEWDECIMAL:   // char[]
+          val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(result_buffer->buffer, *(result_buffer->length)));
+          break;
+        case MYSQL_TYPE_STRING:       // char[]
+        case MYSQL_TYPE_VAR_STRING:   // char[]
+        case MYSQL_TYPE_VARCHAR:      // char[]
+        case MYSQL_TYPE_TINY_BLOB:    // char[]
+        case MYSQL_TYPE_BLOB:         // char[]
+        case MYSQL_TYPE_MEDIUM_BLOB:  // char[]
+        case MYSQL_TYPE_LONG_BLOB:    // char[]
+        case MYSQL_TYPE_BIT:          // char[]
+        case MYSQL_TYPE_SET:          // char[]
+        case MYSQL_TYPE_ENUM:         // char[]
+        case MYSQL_TYPE_GEOMETRY:     // char[]
+          val = rb_str_new(result_buffer->buffer, *(result_buffer->length));
+#ifdef HAVE_RUBY_ENCODING_H
+          val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc);
+#endif
+          break;
+        default:
+          rb_raise(cMysql2Error, "unhandled buffer type: %d",
+              result_buffer->buffer_type);
+      }
+    }
+
+    if (args->asArray) {
+      rb_ary_push(rowVal, val);
+    } else {
+      rb_hash_aset(rowVal, field, val);
+    }
+  }
+
+  return rowVal;
+}
+
+
+static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const result_each_args *args)
+{
   VALUE rowVal;
   MYSQL_ROW row;
   unsigned int i = 0;
@@ -217,7 +537,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
     return Qnil;
   }
 
-  if (asArray) {
+  if (args->asArray) {
     rowVal = rb_ary_new2(wrapper->numberOfFields);
   } else {
     rowVal = rb_hash_new();
@@ -229,12 +549,12 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
   }
 
   for (i = 0; i < wrapper->numberOfFields; i++) {
-    VALUE field = rb_mysql_result_fetch_field(self, i, symbolizeKeys);
+    VALUE field = rb_mysql_result_fetch_field(self, i, args->symbolizeKeys);
     if (row[i]) {
       VALUE val = Qnil;
       enum enum_field_types type = fields[i].type;
 
-      if (!cast) {
+      if (!args->cast) {
         if (type == MYSQL_TYPE_NULL) {
           val = Qnil;
         } else {
@@ -249,14 +569,14 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
           val = Qnil;
           break;
         case MYSQL_TYPE_BIT:        /* BIT field (MySQL 5.0.3 and up) */
-          if (castBool && fields[i].length == 1) {
+          if (args->castBool && fields[i].length == 1) {
             val = *row[i] == 1 ? Qtrue : Qfalse;
           }else{
             val = rb_str_new(row[i], fieldLengths[i]);
           }
           break;
         case MYSQL_TYPE_TINY:       /* TINYINT field */
-          if (castBool && fields[i].length == 1) {
+          if (args->castBool && fields[i].length == 1) {
             val = *row[i] != '0' ? Qtrue : Qfalse;
             break;
           }
@@ -299,9 +619,9 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
             break;
           }
           msec = msec_char_to_uint(msec_char, sizeof(msec_char));
-          val = rb_funcall(rb_cTime, db_timezone, 7, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec));
-          if (!NIL_P(app_timezone)) {
-            if (app_timezone == intern_local) {
+          val = rb_funcall(rb_cTime, args->db_timezone, 7, opt_time_year, opt_time_month, opt_time_month, UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec));
+          if (!NIL_P(args->app_timezone)) {
+            if (args->app_timezone == intern_local) {
               val = rb_funcall(val, intern_localtime, 0);
             } else { /* utc */
               val = rb_funcall(val, intern_utc, 0);
@@ -332,12 +652,12 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
             } else {
               if (seconds < MYSQL2_MIN_TIME || seconds > MYSQL2_MAX_TIME) { /* use DateTime for larger date range, does not support microseconds */
                 VALUE offset = INT2NUM(0);
-                if (db_timezone == intern_local) {
+                if (args->db_timezone == intern_local) {
                   offset = rb_funcall(cMysql2Client, intern_local_offset, 0);
                 }
                 val = rb_funcall(cDateTime, intern_civil, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), offset);
-                if (!NIL_P(app_timezone)) {
-                  if (app_timezone == intern_local) {
+                if (!NIL_P(args->app_timezone)) {
+                  if (args->app_timezone == intern_local) {
                     offset = rb_funcall(cMysql2Client, intern_local_offset, 0);
                     val = rb_funcall(val, intern_new_offset, 1, offset);
                   } else { /* utc */
@@ -346,9 +666,9 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
                 }
               } else {
                 msec = msec_char_to_uint(msec_char, sizeof(msec_char));
-                val = rb_funcall(rb_cTime, db_timezone, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec));
-                if (!NIL_P(app_timezone)) {
-                  if (app_timezone == intern_local) {
+                val = rb_funcall(rb_cTime, args->db_timezone, 7, UINT2NUM(year), UINT2NUM(month), UINT2NUM(day), UINT2NUM(hour), UINT2NUM(min), UINT2NUM(sec), UINT2NUM(msec));
+                if (!NIL_P(args->app_timezone)) {
+                  if (args->app_timezone == intern_local) {
                     val = rb_funcall(val, intern_localtime, 0);
                   } else { /* utc */
                     val = rb_funcall(val, intern_utc, 0);
@@ -398,13 +718,13 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, ID db_timezone, ID app_timezo
           break;
         }
       }
-      if (asArray) {
+      if (args->asArray) {
         rb_ary_push(rowVal, val);
       } else {
         rb_hash_aset(rowVal, field, val);
       }
     } else {
-      if (asArray) {
+      if (args->asArray) {
         rb_ary_push(rowVal, Qnil);
       } else {
         rb_hash_aset(rowVal, field, Qnil);
@@ -432,7 +752,7 @@ static VALUE rb_mysql_result_fetch_fields(VALUE self) {
     wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
   }
 
-  if (RARRAY_LEN(wrapper->fields) != wrapper->numberOfFields) {
+  if ((my_ulonglong)RARRAY_LEN(wrapper->fields) != wrapper->numberOfFields) {
     for (i=0; i<wrapper->numberOfFields; i++) {
       rb_mysql_result_fetch_field(self, i, symbolizeKeys);
     }
@@ -441,55 +761,16 @@ static VALUE rb_mysql_result_fetch_fields(VALUE self) {
   return wrapper->fields;
 }
 
-static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
-  VALUE defaults, opts, block;
-  ID db_timezone, app_timezone, dbTz, appTz;
+static VALUE rb_mysql_result_each_(VALUE self,
+                                   VALUE(*fetch_row_func)(VALUE, MYSQL_FIELD *fields, const result_each_args *args),
+                                   const result_each_args *args)
+{
   unsigned long i;
-  const char * errstr;
-  int symbolizeKeys, asArray, castBool, cacheRows, cast;
-  MYSQL_FIELD * fields = NULL;
+  const char *errstr;
+  MYSQL_FIELD *fields = NULL;
 
   GET_RESULT(self);
 
-  defaults = rb_iv_get(self, "@query_options");
-  Check_Type(defaults, T_HASH);
-  if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
-    opts = rb_funcall(defaults, intern_merge, 1, opts);
-  } else {
-    opts = defaults;
-  }
-
-  symbolizeKeys = RTEST(rb_hash_aref(opts, sym_symbolize_keys));
-  asArray       = rb_hash_aref(opts, sym_as) == sym_array;
-  castBool      = RTEST(rb_hash_aref(opts, sym_cast_booleans));
-  cacheRows     = RTEST(rb_hash_aref(opts, sym_cache_rows));
-  cast          = RTEST(rb_hash_aref(opts, sym_cast));
-
-  if (wrapper->is_streaming && cacheRows) {
-    rb_warn(":cache_rows is ignored if :stream is true");
-  }
-
-  dbTz = rb_hash_aref(opts, sym_database_timezone);
-  if (dbTz == sym_local) {
-    db_timezone = intern_local;
-  } else if (dbTz == sym_utc) {
-    db_timezone = intern_utc;
-  } else {
-    if (!NIL_P(dbTz)) {
-      rb_warn(":database_timezone option must be :utc or :local - defaulting to :local");
-    }
-    db_timezone = intern_local;
-  }
-
-  appTz = rb_hash_aref(opts, sym_application_timezone);
-  if (appTz == sym_local) {
-    app_timezone = intern_local;
-  } else if (appTz == sym_utc) {
-    app_timezone = intern_utc;
-  } else {
-    app_timezone = Qnil;
-  }
-
   if (wrapper->is_streaming) {
     /* When streaming, we will only yield rows, not return them. */
     if (wrapper->rows == Qnil) {
@@ -502,10 +783,10 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
       fields = mysql_fetch_fields(wrapper->result);
 
       do {
-        row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields);
+        row = fetch_row_func(self, fields, args);
         if (row != Qnil) {
           wrapper->numberOfRows++;
-          if (block != Qnil) {
+          if (args->block_given != Qnil) {
             rb_yield(row);
           }
         }
@@ -524,20 +805,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
       rb_raise(cMysql2Error, "You have already fetched all the rows for this query and streaming is true. (to reiterate you must requery).");
     }
   } else {
-    if (wrapper->lastRowProcessed == 0) {
-      wrapper->numberOfRows = mysql_num_rows(wrapper->result);
-      if (wrapper->numberOfRows == 0) {
-        wrapper->rows = rb_ary_new();
-        return wrapper->rows;
-      }
-      wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
-    } else if (!cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) {
-      mysql_data_seek(wrapper->result, 0);
-      wrapper->lastRowProcessed = 0;
-      wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
-    }
-
-    if (cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) {
+    if (args->cacheRows && wrapper->lastRowProcessed == wrapper->numberOfRows) {
       /* we've already read the entire dataset from the C result into our */
       /* internal array. Lets hand that over to the user since it's ready to go */
       for (i = 0; i < wrapper->numberOfRows; i++) {
@@ -550,11 +818,11 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
       for (i = 0; i < wrapper->numberOfRows; i++) {
         VALUE row;
-        if (cacheRows && i < rowsProcessed) {
+        if (args->cacheRows && i < rowsProcessed) {
           row = rb_ary_entry(wrapper->rows, i);
         } else {
-          row = rb_mysql_result_fetch_row(self, db_timezone, app_timezone, symbolizeKeys, asArray, castBool, cast, fields);
-          if (cacheRows) {
+          row = fetch_row_func(self, fields, args);
+          if (args->cacheRows) {
             rb_ary_store(wrapper->rows, i, row);
           }
           wrapper->lastRowProcessed++;
@@ -562,26 +830,109 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
         if (row == Qnil) {
           /* we don't need the mysql C dataset around anymore, peace it */
-          if (cacheRows) {
-            rb_mysql_result_free_result(wrapper);
-          }
+          rb_mysql_result_free_result(wrapper);
           return Qnil;
         }
 
-        if (block != Qnil) {
+        if (args->block_given != Qnil) {
           rb_yield(row);
         }
       }
-      if (wrapper->lastRowProcessed == wrapper->numberOfRows && cacheRows) {
+      if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
         /* we don't need the mysql C dataset around anymore, peace it */
         rb_mysql_result_free_result(wrapper);
       }
     }
   }
 
+  // FIXME return Enumerator instead?
+  // return rb_ary_each(wrapper->rows);
   return wrapper->rows;
 }
 
+static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
+  result_each_args args;
+  VALUE defaults, opts, block, (*fetch_row_func)(VALUE, MYSQL_FIELD *fields, const result_each_args *args);
+  ID db_timezone, app_timezone, dbTz, appTz;
+  int symbolizeKeys, asArray, castBool, cacheRows, cast;
+
+  GET_RESULT(self);
+
+  defaults = rb_iv_get(self, "@query_options");
+  Check_Type(defaults, T_HASH);
+  if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
+    opts = rb_funcall(defaults, intern_merge, 1, opts);
+  } else {
+    opts = defaults;
+  }
+
+  symbolizeKeys = RTEST(rb_hash_aref(opts, sym_symbolize_keys));
+  asArray       = rb_hash_aref(opts, sym_as) == sym_array;
+  castBool      = RTEST(rb_hash_aref(opts, sym_cast_booleans));
+  cacheRows     = RTEST(rb_hash_aref(opts, sym_cache_rows));
+  cast          = RTEST(rb_hash_aref(opts, sym_cast));
+
+  if (wrapper->is_streaming && cacheRows) {
+    rb_warn(":cache_rows is ignored if :stream is true");
+  }
+
+  if (wrapper->stmt_wrapper && !cacheRows && !wrapper->is_streaming) {
+    rb_warn(":cache_rows is forced for prepared statements (if not streaming)");
+  }
+
+  if (wrapper->stmt_wrapper && !cast) {
+    rb_warn(":cast is forced for prepared statements");
+  }
+
+  dbTz = rb_hash_aref(opts, sym_database_timezone);
+  if (dbTz == sym_local) {
+    db_timezone = intern_local;
+  } else if (dbTz == sym_utc) {
+    db_timezone = intern_utc;
+  } else {
+    if (!NIL_P(dbTz)) {
+      rb_warn(":database_timezone option must be :utc or :local - defaulting to :local");
+    }
+    db_timezone = intern_local;
+  }
+
+  appTz = rb_hash_aref(opts, sym_application_timezone);
+  if (appTz == sym_local) {
+    app_timezone = intern_local;
+  } else if (appTz == sym_utc) {
+    app_timezone = intern_utc;
+  } else {
+    app_timezone = Qnil;
+  }
+
+  if (wrapper->lastRowProcessed == 0 && !wrapper->is_streaming) {
+    wrapper->numberOfRows = wrapper->stmt_wrapper ? mysql_stmt_num_rows(wrapper->stmt_wrapper->stmt) : mysql_num_rows(wrapper->result);
+    if (wrapper->numberOfRows == 0) {
+      wrapper->rows = rb_ary_new();
+      return wrapper->rows;
+    }
+    wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
+  }
+
+  // Backward compat
+  args.symbolizeKeys = symbolizeKeys;
+  args.asArray = asArray;
+  args.castBool = castBool;
+  args.cacheRows = cacheRows;
+  args.cast = cast;
+  args.db_timezone = db_timezone;
+  args.app_timezone = app_timezone;
+  args.block_given = block;
+
+  if (wrapper->stmt_wrapper) {
+    fetch_row_func = rb_mysql_result_fetch_row_stmt;
+  } else {
+    fetch_row_func = rb_mysql_result_fetch_row;
+  }
+
+  return rb_mysql_result_each_(self, fetch_row_func, &args);
+}
+
 static VALUE rb_mysql_result_count(VALUE self) {
   GET_RESULT(self);
 
@@ -595,12 +946,16 @@ static VALUE rb_mysql_result_count(VALUE self) {
     return LONG2NUM(RARRAY_LEN(wrapper->rows));
   } else {
     /* MySQL returns an unsigned 64-bit long here */
-    return ULL2NUM(mysql_num_rows(wrapper->result));
+    if (wrapper->stmt_wrapper) {
+      return ULL2NUM(mysql_stmt_num_rows(wrapper->stmt_wrapper->stmt));
+    } else {
+      return ULL2NUM(mysql_num_rows(wrapper->result));
+    }
   }
 }
 
 /* Mysql2::Result */
-VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_RES *r) {
+VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_RES *r, VALUE statement) {
   VALUE obj;
   mysql2_result_wrapper * wrapper;
 
@@ -617,9 +972,21 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
   wrapper->client = client;
   wrapper->client_wrapper = DATA_PTR(client);
   wrapper->client_wrapper->refcount++;
+  wrapper->result_buffers = NULL;
+  wrapper->is_null = NULL;
+  wrapper->error = NULL;
+  wrapper->length = NULL;
+
+  /* Keep a handle to the Statement to ensure it doesn't get garbage collected first */
+  wrapper->statement = statement;
+  if (statement != Qnil) {
+    wrapper->stmt_wrapper = DATA_PTR(statement);
+    wrapper->stmt_wrapper->refcount++;
+  } else {
+    wrapper->stmt_wrapper = NULL;
+  }
 
   rb_obj_call_init(obj, 0, NULL);
-
   rb_iv_set(obj, "@query_options", options);
 
   /* Options that cannot be changed in results.each(...) { |row| }