mysql2 0.4.2 → 0.5.5

data/ext/mysql2/result.c

@@ -1,56 +1,43 @@
 #include <mysql2_ext.h>
 
 #include "mysql_enc_to_ruby.h"
+#define MYSQL2_CHARSETNR_SIZE (sizeof(mysql2_mysql_enc_to_rb)/sizeof(mysql2_mysql_enc_to_rb[0]))
 
-#ifdef HAVE_RUBY_ENCODING_H
 static rb_encoding *binaryEncoding;
-#endif
 
-#if (SIZEOF_INT < SIZEOF_LONG) || defined(HAVE_RUBY_ENCODING_H)
 /* on 64bit platforms we can handle dates way outside 2038-01-19T03:14:07
  *
  * (9999*31557600) + (12*2592000) + (31*86400) + (11*3600) + (59*60) + 59
  */
 #define MYSQL2_MAX_TIME 315578267999ULL
-#else
-/**
- * On 32bit platforms the maximum date the Time class can handle is 2038-01-19T03:14:07
- * 2038 years + 1 month + 19 days + 3 hours + 14 minutes + 7 seconds = 64318634047 seconds
- *
- * (2038*31557600) + (1*2592000) + (19*86400) + (3*3600) + (14*60) + 7
- */
-#define MYSQL2_MAX_TIME 64318634047ULL
-#endif
 
-#if defined(HAVE_RUBY_ENCODING_H)
 /* 0000-1-1 00:00:00 UTC
  *
  * (0*31557600) + (1*2592000) + (1*86400) + (0*3600) + (0*60) + 0
  */
 #define MYSQL2_MIN_TIME 2678400ULL
-#elif SIZEOF_INT < SIZEOF_LONG /* 64bit Ruby 1.8 */
-/* 0139-1-1 00:00:00 UTC
- *
- * (139*31557600) + (1*2592000) + (1*86400) + (0*3600) + (0*60) + 0
- */
-#define MYSQL2_MIN_TIME 4389184800ULL
-#elif defined(NEGATIVE_TIME_T)
-/* 1901-12-13 20:45:52 UTC : The oldest time in 32-bit signed time_t.
- *
- * (1901*31557600) + (12*2592000) + (13*86400) + (20*3600) + (45*60) + 52
- */
-#define MYSQL2_MIN_TIME 60023299552ULL
-#else
-/* 1970-01-01 00:00:01 UTC : The Unix epoch - the oldest time in portable time_t.
- *
- * (1970*31557600) + (1*2592000) + (1*86400) + (0*3600) + (0*60) + 1
+
+#define MYSQL2_MAX_BYTES_PER_CHAR 3
+
+/* From Mysql documentations:
+ *   To distinguish between binary and nonbinary data for string data types,
+ *   check whether the charsetnr value is 63. If so, the character set is binary,
+ *   which indicates binary rather than nonbinary data. This enables you to distinguish BINARY
+ *   from CHAR, VARBINARY from VARCHAR, and the BLOB types from the TEXT types.
  */
-#define MYSQL2_MIN_TIME 62171150401ULL
+#define MYSQL2_BINARY_CHARSET 63
+
+#ifndef MYSQL_TYPE_JSON
+#define MYSQL_TYPE_JSON 245
+#endif
+
+#ifndef NEW_TYPEDDATA_WRAPPER
+#define TypedData_Get_Struct(obj, type, ignore, sval) Data_Get_Struct(obj, type, sval)
 #endif
 
 #define GET_RESULT(self) \
   mysql2_result_wrapper *wrapper; \
-  Data_Get_Struct(self, mysql2_result_wrapper, wrapper);
+  TypedData_Get_Struct(self, mysql2_result_wrapper, &rb_mysql_result_type, wrapper);
 
 typedef struct {
   int symbolizeKeys;
@@ -61,27 +48,28 @@ typedef struct {
   int streaming;
   ID db_timezone;
   ID app_timezone;
-  VALUE block_given;
+  int block_given; /* boolean */
 } result_each_args;
 
-VALUE cBigDecimal, cDateTime, cDate;
-static VALUE cMysql2Result;
-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;
-static VALUE sym_symbolize_keys, sym_as, sym_array, sym_database_timezone, sym_application_timezone,
-          sym_local, sym_utc, sym_cast_booleans, sym_cache_rows, sym_cast, sym_stream, sym_name;
-static ID intern_merge;
+static VALUE cMysql2Result, cDateTime, cDate;
+static VALUE opt_decimal_zero, opt_float_zero, opt_time_year, opt_time_month, opt_utc_offset;
+static ID intern_new, intern_utc, intern_local, intern_localtime, intern_local_offset,
+  intern_civil, intern_new_offset, intern_merge, intern_BigDecimal,
+  intern_query_options;
+static VALUE sym_symbolize_keys, sym_as, sym_array, sym_database_timezone,
+  sym_application_timezone, sym_local, sym_utc, sym_cast_booleans,
+  sym_cache_rows, sym_cast, sym_stream, sym_name;
 
 /* 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) {
-    rb_gc_mark(w->fields);
-    rb_gc_mark(w->rows);
-    rb_gc_mark(w->encoding);
-    rb_gc_mark(w->client);
-    rb_gc_mark(w->statement);
+    rb_gc_mark_movable(w->fields);
+    rb_gc_mark_movable(w->rows);
+    rb_gc_mark_movable(w->encoding);
+    rb_gc_mark_movable(w->client);
+    rb_gc_mark_movable(w->statement);
   }
 }
 
@@ -104,6 +92,10 @@ static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
         wrapper->stmt_wrapper->stmt->bind_result_done = 0;
       }
 
+      if (wrapper->statement != Qnil) {
+        decr_mysql2_stmt(wrapper->stmt_wrapper);
+      }
+
       if (wrapper->result_buffers) {
         unsigned int i;
         for (i = 0; i < wrapper->numberOfFields; i++) {
@@ -136,11 +128,55 @@ 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);
+}
+
+static size_t rb_mysql_result_memsize(const void * wrapper) {
+  const mysql2_result_wrapper * w = wrapper;
+  size_t memsize = sizeof(*w);
+  if (w->stmt_wrapper) {
+    memsize += sizeof(*w->stmt_wrapper);
+  }
+  if (w->client_wrapper) {
+    memsize += sizeof(*w->client_wrapper);
+  }
+  return memsize;
+}
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void rb_mysql_result_compact(void * wrapper) {
+  mysql2_result_wrapper * w = wrapper;
+  if (w) {
+    rb_mysql2_gc_location(w->fields);
+    rb_mysql2_gc_location(w->rows);
+    rb_mysql2_gc_location(w->encoding);
+    rb_mysql2_gc_location(w->client);
+    rb_mysql2_gc_location(w->statement);
   }
+}
+#endif
 
-  xfree(wrapper);
+static const rb_data_type_t rb_mysql_result_type = {
+  "rb_mysql_result",
+  {
+    rb_mysql_result_mark,
+    rb_mysql_result_free,
+    rb_mysql_result_memsize,
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+    rb_mysql_result_compact,
+#endif
+  },
+  0,
+  0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+static VALUE rb_mysql_result_free_(VALUE self) {
+  GET_RESULT(self);
+  rb_mysql_result_free_result(wrapper);
+  return Qnil;
 }
 
 /*
@@ -173,28 +209,25 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbo
   rb_field = rb_ary_entry(wrapper->fields, idx);
   if (rb_field == Qnil) {
     MYSQL_FIELD *field = NULL;
-#ifdef HAVE_RUBY_ENCODING_H
     rb_encoding *default_internal_enc = rb_default_internal_encoding();
     rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
-#endif
 
     field = mysql_fetch_field_direct(wrapper->result, idx);
     if (symbolize_keys) {
-#ifdef HAVE_RB_INTERN3
       rb_field = rb_intern3(field->name, field->name_length, rb_utf8_encoding());
       rb_field = ID2SYM(rb_field);
-#else
-      VALUE colStr;
-      colStr = rb_str_new(field->name, field->name_length);
-      rb_field = ID2SYM(rb_to_id(colStr));
-#endif
     } else {
-      rb_field = rb_str_new(field->name, field->name_length);
-#ifdef HAVE_RUBY_ENCODING_H
-      rb_enc_associate(rb_field, conn_enc);
-      if (default_internal_enc) {
+#ifdef HAVE_RB_ENC_INTERNED_STR
+      rb_field = rb_enc_interned_str(field->name, field->name_length, conn_enc);
+      if (default_internal_enc && default_internal_enc != conn_enc) {
+        rb_field = rb_str_to_interned_str(rb_str_export_to_enc(rb_field, default_internal_enc));
+      }
+#else
+      rb_field = rb_enc_str_new(field->name, field->name_length, conn_enc);
+      if (default_internal_enc && default_internal_enc != conn_enc) {
         rb_field = rb_str_export_to_enc(rb_field, default_internal_enc);
       }
+      rb_obj_freeze(rb_field);
 #endif
     }
     rb_ary_store(wrapper->fields, idx, rb_field);
@@ -203,10 +236,171 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbo
   return rb_field;
 }
 
-#ifdef HAVE_RUBY_ENCODING_H
+static VALUE rb_mysql_result_fetch_field_type(VALUE self, unsigned int idx) {
+  VALUE rb_field_type;
+  GET_RESULT(self);
+
+  if (wrapper->fieldTypes == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fieldTypes = rb_ary_new2(wrapper->numberOfFields);
+  }
+
+  rb_field_type = rb_ary_entry(wrapper->fieldTypes, idx);
+  if (rb_field_type == Qnil) {
+    MYSQL_FIELD *field = NULL;
+    rb_encoding *default_internal_enc = rb_default_internal_encoding();
+    rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
+    int precision;
+
+    field = mysql_fetch_field_direct(wrapper->result, idx);
+
+    switch(field->type) {
+      case MYSQL_TYPE_NULL:         // NULL
+        rb_field_type = rb_str_new_cstr("null");
+        break;
+      case MYSQL_TYPE_TINY:         // signed char
+        rb_field_type = rb_sprintf("tinyint(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_SHORT:        // short int
+        rb_field_type = rb_sprintf("smallint(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_YEAR:         // short int
+        rb_field_type = rb_sprintf("year(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_INT24:        // int
+        rb_field_type = rb_sprintf("mediumint(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_LONG:         // int
+        rb_field_type = rb_sprintf("int(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_LONGLONG:     // long long int
+        rb_field_type = rb_sprintf("bigint(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_FLOAT:        // float
+        rb_field_type = rb_sprintf("float(%ld,%d)", field->length, field->decimals);
+        break;
+      case MYSQL_TYPE_DOUBLE:       // double
+        rb_field_type = rb_sprintf("double(%ld,%d)", field->length, field->decimals);
+        break;
+      case MYSQL_TYPE_TIME:         // MYSQL_TIME
+        rb_field_type = rb_str_new_cstr("time");
+        break;
+      case MYSQL_TYPE_DATE:         // MYSQL_TIME
+      case MYSQL_TYPE_NEWDATE:      // MYSQL_TIME
+        rb_field_type = rb_str_new_cstr("date");
+        break;
+      case MYSQL_TYPE_DATETIME:     // MYSQL_TIME
+        rb_field_type = rb_str_new_cstr("datetime");
+        break;
+      case MYSQL_TYPE_TIMESTAMP:    // MYSQL_TIME
+        rb_field_type = rb_str_new_cstr("timestamp");
+        break;
+      case MYSQL_TYPE_DECIMAL:      // char[]
+      case MYSQL_TYPE_NEWDECIMAL:   // char[]
+        /*
+          Handle precision similar to this line from mysql's code:
+          https://github.com/mysql/mysql-server/blob/ea7d2e2d16ac03afdd9cb72a972a95981107bf51/sql/field.cc#L2246
+        */
+        precision = field->length - (field->decimals > 0 ? 2 : 1);
+        rb_field_type = rb_sprintf("decimal(%d,%d)", precision, field->decimals);
+        break;
+      case MYSQL_TYPE_STRING:       // char[]
+        if (field->flags & ENUM_FLAG) {
+          rb_field_type = rb_str_new_cstr("enum");
+        } else if (field->flags & SET_FLAG) {
+          rb_field_type = rb_str_new_cstr("set");
+        } else {
+          if (field->charsetnr == MYSQL2_BINARY_CHARSET) {
+            rb_field_type = rb_sprintf("binary(%ld)", field->length);
+          } else {
+            rb_field_type = rb_sprintf("char(%ld)", field->length / MYSQL2_MAX_BYTES_PER_CHAR);
+          }
+        }
+        break;
+      case MYSQL_TYPE_VAR_STRING:   // char[]
+        if (field->charsetnr == MYSQL2_BINARY_CHARSET) {
+          rb_field_type = rb_sprintf("varbinary(%ld)", field->length);
+        } else {
+          rb_field_type = rb_sprintf("varchar(%ld)", field->length / MYSQL2_MAX_BYTES_PER_CHAR);
+        }
+        break;
+      case MYSQL_TYPE_VARCHAR:      // char[]
+        rb_field_type = rb_sprintf("varchar(%ld)", field->length / MYSQL2_MAX_BYTES_PER_CHAR);
+        break;
+      case MYSQL_TYPE_TINY_BLOB:    // char[]
+        rb_field_type = rb_str_new_cstr("tinyblob");
+        break;
+      case MYSQL_TYPE_BLOB:         // char[]
+        if (field->charsetnr == MYSQL2_BINARY_CHARSET) {
+          switch(field->length) {
+            case 255:
+              rb_field_type = rb_str_new_cstr("tinyblob");
+              break;
+            case 65535:
+              rb_field_type = rb_str_new_cstr("blob");
+              break;
+            case 16777215:
+              rb_field_type = rb_str_new_cstr("mediumblob");
+              break;
+            case 4294967295:
+              rb_field_type = rb_str_new_cstr("longblob");
+            default:
+              break;
+          }
+        } else {
+          if (field->length == (255 * MYSQL2_MAX_BYTES_PER_CHAR)) {
+            rb_field_type = rb_str_new_cstr("tinytext");
+          } else if (field->length == (65535 * MYSQL2_MAX_BYTES_PER_CHAR)) {
+            rb_field_type = rb_str_new_cstr("text");
+          } else if (field->length == (16777215 * MYSQL2_MAX_BYTES_PER_CHAR)) {
+            rb_field_type = rb_str_new_cstr("mediumtext");
+          } else if (field->length == 4294967295) {
+            rb_field_type = rb_str_new_cstr("longtext");
+          } else {
+            rb_field_type = rb_sprintf("text(%ld)", field->length);
+          }
+        }
+        break;
+      case MYSQL_TYPE_MEDIUM_BLOB:  // char[]
+        rb_field_type = rb_str_new_cstr("mediumblob");
+        break;
+      case MYSQL_TYPE_LONG_BLOB:    // char[]
+        rb_field_type = rb_str_new_cstr("longblob");
+        break;
+      case MYSQL_TYPE_BIT:          // char[]
+        rb_field_type = rb_sprintf("bit(%ld)", field->length);
+        break;
+      case MYSQL_TYPE_SET:          // char[]
+        rb_field_type = rb_str_new_cstr("set");
+        break;
+      case MYSQL_TYPE_ENUM:         // char[]
+        rb_field_type = rb_str_new_cstr("enum");
+        break;
+      case MYSQL_TYPE_GEOMETRY:     // char[]
+        rb_field_type = rb_str_new_cstr("geometry");
+        break;
+      case MYSQL_TYPE_JSON:         // json
+        rb_field_type = rb_str_new_cstr("json");
+        break;
+      default:
+        rb_field_type = rb_str_new_cstr("unknown");
+        break;
+    }
+
+    rb_enc_associate(rb_field_type, conn_enc);
+    if (default_internal_enc) {
+      rb_field_type = rb_str_export_to_enc(rb_field_type, default_internal_enc);
+    }
+
+    rb_ary_store(wrapper->fieldTypes, idx, rb_field_type);
+  }
+
+  return rb_field_type;
+}
+
 static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_encoding *default_internal_enc, rb_encoding *conn_enc) {
   /* if binary flag is set, respect its wishes */
-  if (field.flags & BINARY_FLAG && field.charsetnr == 63) {
+  if (field.flags & BINARY_FLAG && field.charsetnr == MYSQL2_BINARY_CHARSET) {
     rb_enc_associate(val, binaryEncoding);
   } else if (!field.charsetnr) {
     /* MySQL 4.x may not provide an encoding, binary will get the bytes through */
@@ -216,7 +410,8 @@ static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_e
     const char *enc_name;
     int enc_index;
 
-    enc_name = mysql2_mysql_enc_to_rb[field.charsetnr-1];
+    enc_name = (field.charsetnr-1 < MYSQL2_CHARSETNR_SIZE) ? mysql2_mysql_enc_to_rb[field.charsetnr-1] : NULL;
+
     if (enc_name != NULL) {
       /* use the field encoding we were able to match */
       enc_index = rb_enc_find_index(enc_name);
@@ -232,7 +427,6 @@ static VALUE mysql2_set_field_string_encoding(VALUE val, MYSQL_FIELD field, rb_e
   }
   return val;
 }
-#endif
 
 /* Interpret microseconds digits left-aligned in fixed-width field.
  * e.g. 10.123 seconds means 10 seconds and 123000 microseconds,
@@ -272,12 +466,12 @@ static void rb_mysql_result_alloc_result_buffers(VALUE self, MYSQL_FIELD *fields
         wrapper->result_buffers[i].buffer_length = sizeof(signed char);
         break;
       case MYSQL_TYPE_SHORT:        // short int
+      case MYSQL_TYPE_YEAR:         // 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;
@@ -329,26 +523,22 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
   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 (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
   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);
@@ -399,7 +589,15 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
             val = INT2NUM(*((signed char*)result_buffer->buffer));
           }
           break;
+        case MYSQL_TYPE_BIT:        /* BIT field (MySQL 5.0.3 and up) */
+          if (args->castBool && fields[i].length == 1) {
+            val = (*((unsigned char*)result_buffer->buffer) != 0) ? Qtrue : Qfalse;
+          }else{
+            val = rb_str_new(result_buffer->buffer, *(result_buffer->length));
+          }
+          break;
         case MYSQL_TYPE_SHORT:        // short int
+        case MYSQL_TYPE_YEAR:         // short int
           if (result_buffer->is_unsigned) {
             val = UINT2NUM(*((unsigned short int*)result_buffer->buffer));
           } else  {
@@ -408,7 +606,6 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
           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 {
@@ -479,7 +676,7 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
         }
         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)));
+          val = rb_funcall(rb_mKernel, intern_BigDecimal, 1, rb_str_new(result_buffer->buffer, *(result_buffer->length)));
           break;
         case MYSQL_TYPE_STRING:       // char[]
         case MYSQL_TYPE_VAR_STRING:   // char[]
@@ -488,15 +685,12 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
         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[]
         default:
           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;
       }
     }
@@ -511,7 +705,6 @@ static VALUE rb_mysql_result_fetch_row_stmt(VALUE self, MYSQL_FIELD * fields, co
   return rowVal;
 }
 
-
 static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const result_each_args *args)
 {
   VALUE rowVal;
@@ -519,16 +712,12 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const r
   unsigned int i = 0;
   unsigned long * fieldLengths;
   void * ptr;
-#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
 
   ptr = wrapper->result;
   row = (MYSQL_ROW)rb_thread_call_without_gvl(nogvl_fetch_row, ptr, RUBY_UBF_IO, 0);
@@ -536,16 +725,16 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const r
     return Qnil;
   }
 
+  if (wrapper->fields == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
+  }
   if (args->asArray) {
     rowVal = rb_ary_new2(wrapper->numberOfFields);
   } else {
     rowVal = rb_hash_new();
   }
   fieldLengths = mysql_fetch_lengths(wrapper->result);
-  if (wrapper->fields == Qnil) {
-    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
-    wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
-  }
 
   for (i = 0; i < wrapper->numberOfFields; i++) {
     VALUE field = rb_mysql_result_fetch_field(self, i, args->symbolizeKeys);
@@ -558,9 +747,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const r
           val = Qnil;
         } else {
           val = rb_str_new(row[i], fieldLengths[i]);
-#ifdef HAVE_RUBY_ENCODING_H
           val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc);
-#endif
         }
       } else {
         switch(type) {
@@ -591,9 +778,9 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const r
           if (fields[i].decimals == 0) {
             val = rb_cstr2inum(row[i], 10);
           } else if (strtod(row[i], NULL) == 0.000000){
-            val = rb_funcall(cBigDecimal, intern_new, 1, opt_decimal_zero);
+            val = rb_funcall(rb_mKernel, intern_BigDecimal, 1, opt_decimal_zero);
           }else{
-            val = rb_funcall(cBigDecimal, intern_new, 1, rb_str_new(row[i], fieldLengths[i]));
+            val = rb_funcall(rb_mKernel, intern_BigDecimal, 1, rb_str_new(row[i], fieldLengths[i]));
           }
           break;
         case MYSQL_TYPE_FLOAT:      /* FLOAT field */
@@ -711,9 +898,7 @@ static VALUE rb_mysql_result_fetch_row(VALUE self, MYSQL_FIELD * fields, const r
         case MYSQL_TYPE_GEOMETRY:   /* Spatial fielda */
         default:
           val = rb_str_new(row[i], fieldLengths[i]);
-#ifdef HAVE_RUBY_ENCODING_H
           val = mysql2_set_field_string_encoding(val, fields[i], default_internal_enc, conn_enc);
-#endif
           break;
         }
       }
@@ -740,7 +925,7 @@ static VALUE rb_mysql_result_fetch_fields(VALUE self) {
 
   GET_RESULT(self);
 
-  defaults = rb_iv_get(self, "@query_options");
+  defaults = rb_ivar_get(self, intern_query_options);
   Check_Type(defaults, T_HASH);
   if (rb_hash_aref(defaults, sym_symbolize_keys) == Qtrue) {
     symbolizeKeys = 1;
@@ -760,6 +945,25 @@ static VALUE rb_mysql_result_fetch_fields(VALUE self) {
   return wrapper->fields;
 }
 
+static VALUE rb_mysql_result_fetch_field_types(VALUE self) {
+  unsigned int i = 0;
+
+  GET_RESULT(self);
+
+  if (wrapper->fieldTypes == Qnil) {
+    wrapper->numberOfFields = mysql_num_fields(wrapper->result);
+    wrapper->fieldTypes = rb_ary_new2(wrapper->numberOfFields);
+  }
+
+  if ((my_ulonglong)RARRAY_LEN(wrapper->fieldTypes) != wrapper->numberOfFields) {
+    for (i=0; i<wrapper->numberOfFields; i++) {
+      rb_mysql_result_fetch_field_type(self, i);
+    }
+  }
+
+  return wrapper->fieldTypes;
+}
+
 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)
@@ -785,7 +989,7 @@ static VALUE rb_mysql_result_each_(VALUE self,
         row = fetch_row_func(self, fields, args);
         if (row != Qnil) {
           wrapper->numberOfRows++;
-          if (args->block_given != Qnil) {
+          if (args->block_given) {
             rb_yield(row);
           }
         }
@@ -829,15 +1033,17 @@ static VALUE rb_mysql_result_each_(VALUE self,
 
         if (row == Qnil) {
           /* we don't need the mysql C dataset around anymore, peace it */
-          rb_mysql_result_free_result(wrapper);
+          if (args->cacheRows) {
+            rb_mysql_result_free_result(wrapper);
+          }
           return Qnil;
         }
 
-        if (args->block_given != Qnil) {
+        if (args->block_given) {
           rb_yield(row);
         }
       }
-      if (wrapper->lastRowProcessed == wrapper->numberOfRows) {
+      if (wrapper->lastRowProcessed == wrapper->numberOfRows && args->cacheRows) {
         /* we don't need the mysql C dataset around anymore, peace it */
         rb_mysql_result_free_result(wrapper);
       }
@@ -851,7 +1057,7 @@ static VALUE rb_mysql_result_each_(VALUE self,
 
 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);
+  VALUE defaults, opts, (*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;
 
@@ -861,9 +1067,12 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     rb_raise(cMysql2Error, "Statement handle already closed");
   }
 
-  defaults = rb_iv_get(self, "@query_options");
+  defaults = rb_ivar_get(self, intern_query_options);
   Check_Type(defaults, T_HASH);
-  if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1) {
+
+  // A block can be passed to this method, but since we don't call the block directly from C,
+  // we don't need to capture it into a variable here with the "&" scan arg.
+  if (rb_scan_args(argc, argv, "01", &opts) == 1) {
     opts = rb_funcall(defaults, intern_merge, 1, opts);
   } else {
     opts = defaults;
@@ -881,6 +1090,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
 
   if (wrapper->stmt_wrapper && !cacheRows && !wrapper->is_streaming) {
     rb_warn(":cache_rows is forced for prepared statements (if not streaming)");
+    cacheRows = 1;
   }
 
   if (wrapper->stmt_wrapper && !cast) {
@@ -908,12 +1118,15 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
     app_timezone = Qnil;
   }
 
-  if (wrapper->lastRowProcessed == 0 && !wrapper->is_streaming) {
+  if (wrapper->rows == Qnil && !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);
+  } else if (wrapper->rows && !cacheRows) {
+    if (wrapper->resultFreed) {
+      rb_raise(cMysql2Error, "Result set has already been freed");
     }
+    mysql_data_seek(wrapper->result, 0);
+    wrapper->lastRowProcessed = 0;
     wrapper->rows = rb_ary_new2(wrapper->numberOfRows);
   }
 
@@ -925,7 +1138,7 @@ static VALUE rb_mysql_result_each(int argc, VALUE * argv, VALUE self) {
   args.cast = cast;
   args.db_timezone = db_timezone;
   args.app_timezone = app_timezone;
-  args.block_given = block;
+  args.block_given = rb_block_given_p();
 
   if (wrapper->stmt_wrapper) {
     fetch_row_func = rb_mysql_result_fetch_row_stmt;
@@ -962,13 +1175,18 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
   VALUE obj;
   mysql2_result_wrapper * wrapper;
 
+#ifdef NEW_TYPEDDATA_WRAPPER
+  obj = TypedData_Make_Struct(cMysql2Result, mysql2_result_wrapper, &rb_mysql_result_type, wrapper);
+#else
   obj = Data_Make_Struct(cMysql2Result, mysql2_result_wrapper, rb_mysql_result_mark, rb_mysql_result_free, wrapper);
+#endif
   wrapper->numberOfFields = 0;
   wrapper->numberOfRows = 0;
   wrapper->lastRowProcessed = 0;
   wrapper->resultFreed = 0;
   wrapper->result = r;
   wrapper->fields = Qnil;
+  wrapper->fieldTypes = Qnil;
   wrapper->rows = Qnil;
   wrapper->encoding = encoding;
   wrapper->streamingComplete = 0;
@@ -990,7 +1208,7 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
   }
 
   rb_obj_call_init(obj, 0, NULL);
-  rb_iv_set(obj, "@query_options", options);
+  rb_ivar_set(obj, intern_query_options, options);
 
   /* Options that cannot be changed in results.each(...) { |row| }
    * should be processed here. */
@@ -1000,13 +1218,19 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
 }
 
 void init_mysql2_result() {
-  cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
   cDate = rb_const_get(rb_cObject, rb_intern("Date"));
+  rb_global_variable(&cDate);
   cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+  rb_global_variable(&cDateTime);
 
   cMysql2Result = rb_define_class_under(mMysql2, "Result", rb_cObject);
+  rb_undef_alloc_func(cMysql2Result);
+  rb_global_variable(&cMysql2Result);
+
   rb_define_method(cMysql2Result, "each", rb_mysql_result_each, -1);
   rb_define_method(cMysql2Result, "fields", rb_mysql_result_fetch_fields, 0);
+  rb_define_method(cMysql2Result, "field_types", rb_mysql_result_fetch_field_types, 0);
+  rb_define_method(cMysql2Result, "free", rb_mysql_result_free_, 0);
   rb_define_method(cMysql2Result, "count", rb_mysql_result_count, 0);
   rb_define_alias(cMysql2Result, "size", "count");
 
@@ -1018,6 +1242,8 @@ void init_mysql2_result() {
   intern_local_offset = rb_intern("local_offset");
   intern_civil        = rb_intern("civil");
   intern_new_offset   = rb_intern("new_offset");
+  intern_BigDecimal   = rb_intern("BigDecimal");
+  intern_query_options = rb_intern("@query_options");
 
   sym_symbolize_keys  = ID2SYM(rb_intern("symbolize_keys"));
   sym_as              = ID2SYM(rb_intern("as"));
@@ -1040,7 +1266,5 @@ void init_mysql2_result() {
   opt_time_month = INT2NUM(1);
   opt_utc_offset = INT2NUM(0);
 
-#ifdef HAVE_RUBY_ENCODING_H
   binaryEncoding = rb_enc_find("binary");
-#endif
 }