mysql2 0.5.2 → 0.5.6

data/ext/mysql2/result.c

@@ -1,6 +1,7 @@
 #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]))
 
 static rb_encoding *binaryEncoding;
 
@@ -16,9 +17,27 @@ static rb_encoding *binaryEncoding;
  */
 #define MYSQL2_MIN_TIME 2678400ULL
 
+#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_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;
@@ -29,14 +48,15 @@ typedef struct {
   int streaming;
   ID db_timezone;
   ID app_timezone;
-  VALUE block_given;
+  int block_given; /* boolean */
 } result_each_args;
 
 extern VALUE mMysql2, cMysql2Client, cMysql2Error;
 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_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;
@@ -45,11 +65,11 @@ static VALUE sym_symbolize_keys, sym_as, sym_array, sym_database_timezone,
 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);
   }
 }
 
@@ -111,6 +131,48 @@ static void rb_mysql_result_free(void *ptr) {
   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
+
+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);
@@ -155,11 +217,18 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbo
       rb_field = rb_intern3(field->name, field->name_length, rb_utf8_encoding());
       rb_field = ID2SYM(rb_field);
     } else {
-      rb_field = rb_str_new(field->name, field->name_length);
-      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);
   }
@@ -167,9 +236,171 @@ static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbo
   return rb_field;
 }
 
+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 */
@@ -179,8 +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 = (field.charsetnr-1 < CHARSETNR_SIZE) ? mysql2_mysql_enc_to_rb[field.charsetnr-1] : NULL;
-    
+    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);
@@ -694,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;
@@ -714,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)
@@ -739,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);
           }
         }
@@ -789,7 +1039,7 @@ static VALUE rb_mysql_result_each_(VALUE self,
           return Qnil;
         }
 
-        if (args->block_given != Qnil) {
+        if (args->block_given) {
           rb_yield(row);
         }
       }
@@ -807,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;
 
@@ -817,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;
@@ -885,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;
@@ -922,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;
@@ -950,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. */
@@ -961,11 +1219,17 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
 
 void init_mysql2_result() {
   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");
@@ -979,6 +1243,7 @@ void init_mysql2_result() {
   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"));

data/ext/mysql2/result.h

@@ -6,6 +6,7 @@ VALUE rb_mysql_result_to_obj(VALUE client, VALUE encoding, VALUE options, MYSQL_
 
 typedef struct {
   VALUE fields;
+  VALUE fieldTypes;
   VALUE rows;
   VALUE client;
   VALUE encoding;

data/ext/mysql2/statement.c

@@ -3,11 +3,16 @@
 extern VALUE mMysql2, cMysql2Error;
 static VALUE cMysql2Statement, cBigDecimal, cDateTime, cDate;
 static VALUE sym_stream, intern_new_with_args, intern_each, intern_to_s, intern_merge_bang;
-static VALUE intern_sec_fraction, intern_usec, intern_sec, intern_min, intern_hour, intern_day, intern_month, intern_year;
+static VALUE intern_sec_fraction, intern_usec, intern_sec, intern_min, intern_hour, intern_day, intern_month, intern_year,
+  intern_query_options;
+
+#ifndef NEW_TYPEDDATA_WRAPPER
+#define TypedData_Get_Struct(obj, type, ignore, sval) Data_Get_Struct(obj, type, sval)
+#endif
 
 #define GET_STATEMENT(self) \
   mysql_stmt_wrapper *stmt_wrapper; \
-  Data_Get_Struct(self, mysql_stmt_wrapper, stmt_wrapper); \
+  TypedData_Get_Struct(self, mysql_stmt_wrapper, &rb_mysql_statement_type, stmt_wrapper); \
   if (!stmt_wrapper->stmt) { rb_raise(cMysql2Error, "Invalid statement handle"); } \
   if (stmt_wrapper->closed) { rb_raise(cMysql2Error, "Statement handle already closed"); }
 
@@ -15,9 +20,45 @@ static void rb_mysql_stmt_mark(void * ptr) {
   mysql_stmt_wrapper *stmt_wrapper = ptr;
   if (!stmt_wrapper) return;
 
-  rb_gc_mark(stmt_wrapper->client);
+  rb_gc_mark_movable(stmt_wrapper->client);
+}
+
+static void rb_mysql_stmt_free(void *ptr) {
+  mysql_stmt_wrapper *stmt_wrapper = ptr;
+  decr_mysql2_stmt(stmt_wrapper);
 }
 
+static size_t rb_mysql_stmt_memsize(const void * ptr) {
+  const mysql_stmt_wrapper *stmt_wrapper = ptr;
+  return sizeof(*stmt_wrapper);
+}
+
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+static void rb_mysql_stmt_compact(void * ptr) {
+  mysql_stmt_wrapper *stmt_wrapper = ptr;
+  if (!stmt_wrapper) return;
+
+  rb_mysql2_gc_location(stmt_wrapper->client);
+}
+#endif
+
+static const rb_data_type_t rb_mysql_statement_type = {
+  "rb_mysql_statement",
+  {
+    rb_mysql_stmt_mark,
+    rb_mysql_stmt_free,
+    rb_mysql_stmt_memsize,
+#ifdef HAVE_RB_GC_MARK_MOVABLE
+    rb_mysql_stmt_compact,
+#endif
+  },
+  0,
+  0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
 static void *nogvl_stmt_close(void *ptr) {
   mysql_stmt_wrapper *stmt_wrapper = ptr;
   if (stmt_wrapper->stmt) {
@@ -27,11 +68,6 @@ static void *nogvl_stmt_close(void *ptr) {
   return NULL;
 }
 
-static void rb_mysql_stmt_free(void *ptr) {
-  mysql_stmt_wrapper *stmt_wrapper = ptr;
-  decr_mysql2_stmt(stmt_wrapper);
-}
-
 void decr_mysql2_stmt(mysql_stmt_wrapper *stmt_wrapper) {
   stmt_wrapper->refcount--;
 
@@ -45,7 +81,7 @@ void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) {
   VALUE e;
   GET_CLIENT(stmt_wrapper->client);
   VALUE rb_error_msg = rb_str_new2(mysql_stmt_error(stmt_wrapper->stmt));
-  VALUE rb_sql_state = rb_tainted_str_new2(mysql_stmt_sqlstate(stmt_wrapper->stmt));
+  VALUE rb_sql_state = rb_str_new2(mysql_stmt_sqlstate(stmt_wrapper->stmt));
 
   rb_encoding *conn_enc;
   conn_enc = rb_to_encoding(wrapper->encoding);
@@ -95,7 +131,11 @@ VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
 
   Check_Type(sql, T_STRING);
 
+#ifdef NEW_TYPEDDATA_WRAPPER
+  rb_stmt = TypedData_Make_Struct(cMysql2Statement, mysql_stmt_wrapper, &rb_mysql_statement_type, stmt_wrapper);
+#else
   rb_stmt = Data_Make_Struct(cMysql2Statement, mysql_stmt_wrapper, rb_mysql_stmt_mark, rb_mysql_stmt_free, stmt_wrapper);
+#endif
   {
     stmt_wrapper->client = rb_client;
     stmt_wrapper->refcount = 1;
@@ -404,7 +444,7 @@ static VALUE rb_mysql_stmt_execute(int argc, VALUE *argv, VALUE self) {
   }
 
   // Duplicate the options hash, merge! extra opts, put the copy into the Result object
-  current = rb_hash_dup(rb_iv_get(stmt_wrapper->client, "@query_options"));
+  current = rb_hash_dup(rb_ivar_get(stmt_wrapper->client, intern_query_options));
   (void)RB_GC_GUARD(current);
   Check_Type(current, T_HASH);
 
@@ -447,7 +487,7 @@ static VALUE rb_mysql_stmt_execute(int argc, VALUE *argv, VALUE self) {
   if (metadata == NULL) {
     if (mysql_stmt_errno(stmt) != 0) {
       // either CR_OUT_OF_MEMORY or CR_UNKNOWN_ERROR. both fatal.
-      wrapper->active_thread = Qnil;
+      wrapper->active_fiber = Qnil;
       rb_raise_mysql2_stmt_error(stmt_wrapper);
     }
     // no data and no error, so query was not a SELECT
@@ -455,12 +495,12 @@ static VALUE rb_mysql_stmt_execute(int argc, VALUE *argv, VALUE self) {
   }
 
   if (!is_streaming) {
-    // recieve the whole result set from the server
+    // receive the whole result set from the server
     if (mysql_stmt_store_result(stmt)) {
       mysql_free_result(metadata);
       rb_raise_mysql2_stmt_error(stmt_wrapper);
     }
-    wrapper->active_thread = Qnil;
+    wrapper->active_fiber = Qnil;
   }
 
   resultObj = rb_mysql_result_to_obj(stmt_wrapper->client, wrapper->encoding, current, metadata, self);
@@ -501,7 +541,7 @@ static VALUE rb_mysql_stmt_fields(VALUE self) {
   if (metadata == NULL) {
     if (mysql_stmt_errno(stmt) != 0) {
       // either CR_OUT_OF_MEMORY or CR_UNKNOWN_ERROR. both fatal.
-      wrapper->active_thread = Qnil;
+      wrapper->active_fiber = Qnil;
       rb_raise_mysql2_stmt_error(stmt_wrapper);
     }
     // no data and no error, so query was not a SELECT
@@ -571,10 +611,18 @@ static VALUE rb_mysql_stmt_close(VALUE self) {
 
 void init_mysql2_statement() {
   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);
+
   cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+  rb_global_variable(&cBigDecimal);
 
   cMysql2Statement = rb_define_class_under(mMysql2, "Statement", rb_cObject);
+  rb_undef_alloc_func(cMysql2Statement);
+  rb_global_variable(&cMysql2Statement);
+
   rb_define_method(cMysql2Statement, "param_count", rb_mysql_stmt_param_count, 0);
   rb_define_method(cMysql2Statement, "field_count", rb_mysql_stmt_field_count, 0);
   rb_define_method(cMysql2Statement, "_execute", rb_mysql_stmt_execute, -1);
@@ -599,4 +647,5 @@ void init_mysql2_statement() {
 
   intern_to_s = rb_intern("to_s");
   intern_merge_bang = rb_intern("merge!");
+  intern_query_options = rb_intern("@query_options");
 }