pg 1.2.3-x64-mingw32 → 1.3.0.rc4-x64-mingw32

data/ext/pg_copy_coder.c

@@ -21,18 +21,47 @@ typedef struct {
 
 
 static void
-pg_copycoder_mark( t_pg_copycoder *this )
+pg_copycoder_mark( void *_this )
 {
-	pg_coder_mark(&this->comp);
-	rb_gc_mark(this->typemap);
-	rb_gc_mark(this->null_string);
+	t_pg_copycoder *this = (t_pg_copycoder *)_this;
+	rb_gc_mark_movable(this->typemap);
+	rb_gc_mark_movable(this->null_string);
 }
 
+static size_t
+pg_copycoder_memsize( const void *_this )
+{
+	const t_pg_copycoder *this = (const t_pg_copycoder *)_this;
+	return sizeof(*this);
+}
+
+static void
+pg_copycoder_compact( void *_this )
+{
+	t_pg_copycoder *this = (t_pg_copycoder *)_this;
+	pg_coder_compact(&this->comp);
+	pg_gc_location(this->typemap);
+	pg_gc_location(this->null_string);
+}
+
+static const rb_data_type_t pg_copycoder_type = {
+	"PG::CopyCoder",
+	{
+		pg_copycoder_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_copycoder_memsize,
+		pg_compact_callback(pg_copycoder_compact),
+	},
+	&pg_coder_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE
 pg_copycoder_encoder_allocate( VALUE klass )
 {
 	t_pg_copycoder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_copycoder, pg_copycoder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_copycoder, &pg_copycoder_type, this );
 	pg_coder_init_encoder( self );
 	this->typemap = pg_typemap_all_strings;
 	this->delimiter = '\t';
@@ -44,7 +73,7 @@ static VALUE
 pg_copycoder_decoder_allocate( VALUE klass )
 {
 	t_pg_copycoder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_copycoder, pg_copycoder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_copycoder, &pg_copycoder_type, this );
 	pg_coder_init_decoder( self );
 	this->typemap = pg_typemap_all_strings;
 	this->delimiter = '\t';
@@ -63,7 +92,7 @@ pg_copycoder_decoder_allocate( VALUE klass )
 static VALUE
 pg_copycoder_delimiter_set(VALUE self, VALUE delimiter)
 {
-	t_pg_copycoder *this = DATA_PTR(self);
+	t_pg_copycoder *this = RTYPEDDATA_DATA(self);
 	StringValue(delimiter);
 	if(RSTRING_LEN(delimiter) != 1)
 		rb_raise( rb_eArgError, "delimiter size must be one byte");
@@ -80,7 +109,7 @@ pg_copycoder_delimiter_set(VALUE self, VALUE delimiter)
 static VALUE
 pg_copycoder_delimiter_get(VALUE self)
 {
-	t_pg_copycoder *this = DATA_PTR(self);
+	t_pg_copycoder *this = RTYPEDDATA_DATA(self);
 	return rb_str_new(&this->delimiter, 1);
 }
 
@@ -93,7 +122,7 @@ pg_copycoder_delimiter_get(VALUE self)
 static VALUE
 pg_copycoder_null_string_set(VALUE self, VALUE null_string)
 {
-	t_pg_copycoder *this = DATA_PTR(self);
+	t_pg_copycoder *this = RTYPEDDATA_DATA(self);
 	StringValue(null_string);
 	this->null_string = null_string;
 	return null_string;
@@ -105,7 +134,7 @@ pg_copycoder_null_string_set(VALUE self, VALUE null_string)
 static VALUE
 pg_copycoder_null_string_get(VALUE self)
 {
-	t_pg_copycoder *this = DATA_PTR(self);
+	t_pg_copycoder *this = RTYPEDDATA_DATA(self);
 	return this->null_string;
 }
 
@@ -123,7 +152,7 @@ pg_copycoder_null_string_get(VALUE self)
 static VALUE
 pg_copycoder_type_map_set(VALUE self, VALUE type_map)
 {
-	t_pg_copycoder *this = DATA_PTR( self );
+	t_pg_copycoder *this = RTYPEDDATA_DATA( self );
 
 	if ( !rb_obj_is_kind_of(type_map, rb_cTypeMap) ){
 		rb_raise( rb_eTypeError, "wrong elements type %s (expected some kind of PG::TypeMap)",
@@ -143,7 +172,7 @@ pg_copycoder_type_map_set(VALUE self, VALUE type_map)
 static VALUE
 pg_copycoder_type_map_get(VALUE self)
 {
-	t_pg_copycoder *this = DATA_PTR( self );
+	t_pg_copycoder *this = RTYPEDDATA_DATA( self );
 
 	return this->typemap;
 }
@@ -188,7 +217,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 	char *current_out;
 	char *end_capa_ptr;
 
-	p_typemap = DATA_PTR( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( this->typemap );
 	p_typemap->funcs.fit_to_query( this->typemap, value );
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
@@ -225,7 +254,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 
 				if( strlen == -1 ){
 					/* we can directly use String value in subint */
-					strlen = RSTRING_LEN(subint);
+					strlen = RSTRING_LENINT(subint);
 
 					/* size of string assuming the worst case, that every character must be escaped. */
 					PG_RB_STR_ENSURE_CAPA( *intermediate, strlen * 2, current_out, end_capa_ptr );
@@ -376,7 +405,7 @@ pg_text_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tup
 	char *end_capa_ptr;
 	t_typemap *p_typemap;
 
-	p_typemap = DATA_PTR( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( this->typemap );
 	expected_fields = p_typemap->funcs.fit_to_copy_get( this->typemap );
 
 	/* The received input string will probably have this->nfields fields. */
@@ -397,7 +426,7 @@ pg_text_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tup
 		int found_delim = 0;
 		const char *start_ptr;
 		const char *end_ptr;
-		int input_len;
+		long input_len;
 
 		/* Remember start of field on input side */
 		start_ptr = cur_ptr;

data/ext/pg_record_coder.c

@@ -16,17 +16,45 @@ typedef struct {
 
 
 static void
-pg_recordcoder_mark( t_pg_recordcoder *this )
+pg_recordcoder_mark( void *_this )
 {
-	pg_coder_mark(&this->comp);
-	rb_gc_mark(this->typemap);
+	t_pg_recordcoder *this = (t_pg_recordcoder *)_this;
+	rb_gc_mark_movable(this->typemap);
 }
 
+static size_t
+pg_recordcoder_memsize( const void *_this )
+{
+	const t_pg_recordcoder *this = (const t_pg_recordcoder *)_this;
+	return sizeof(*this);
+}
+
+static void
+pg_recordcoder_compact( void *_this )
+{
+	t_pg_recordcoder *this = (t_pg_recordcoder *)_this;
+	pg_coder_compact(&this->comp);
+	pg_gc_location(this->typemap);
+}
+
+static const rb_data_type_t pg_recordcoder_type = {
+	"PG::RecordCoder",
+	{
+		pg_recordcoder_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_recordcoder_memsize,
+		pg_compact_callback(pg_recordcoder_compact),
+	},
+	&pg_coder_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE
 pg_recordcoder_encoder_allocate( VALUE klass )
 {
 	t_pg_recordcoder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_recordcoder, pg_recordcoder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_recordcoder, &pg_recordcoder_type, this );
 	pg_coder_init_encoder( self );
 	this->typemap = pg_typemap_all_strings;
 	return self;
@@ -36,7 +64,7 @@ static VALUE
 pg_recordcoder_decoder_allocate( VALUE klass )
 {
 	t_pg_recordcoder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_recordcoder, pg_recordcoder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_recordcoder, &pg_recordcoder_type, this );
 	pg_coder_init_decoder( self );
 	this->typemap = pg_typemap_all_strings;
 	return self;
@@ -56,7 +84,7 @@ pg_recordcoder_decoder_allocate( VALUE klass )
 static VALUE
 pg_recordcoder_type_map_set(VALUE self, VALUE type_map)
 {
-	t_pg_recordcoder *this = DATA_PTR( self );
+	t_pg_recordcoder *this = RTYPEDDATA_DATA( self );
 
 	if ( !rb_obj_is_kind_of(type_map, rb_cTypeMap) ){
 		rb_raise( rb_eTypeError, "wrong elements type %s (expected some kind of PG::TypeMap)",
@@ -76,7 +104,7 @@ pg_recordcoder_type_map_set(VALUE self, VALUE type_map)
 static VALUE
 pg_recordcoder_type_map_get(VALUE self)
 {
-	t_pg_recordcoder *this = DATA_PTR( self );
+	t_pg_recordcoder *this = RTYPEDDATA_DATA( self );
 
 	return this->typemap;
 }
@@ -106,7 +134,7 @@ pg_recordcoder_type_map_get(VALUE self)
  *   tm = PG::TypeMapByColumn.new([PG::TextEncoder::Float.new]*2)
  *   # Use this type map to encode the record:
  *   PG::TextEncoder::Record.new(type_map: tm).encode([1,2])
- *   # => "(\"1.0000000000000000E+00\",\"2.0000000000000000E+00\")"
+ *   # => "(\"1.0\",\"2.0\")"
  *
  * Records can also be encoded and decoded directly to and from the database.
  * This avoids intermediate string allocations and is very fast.
@@ -156,7 +184,7 @@ pg_text_enc_record(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 	char *current_out;
 	char *end_capa_ptr;
 
-	p_typemap = DATA_PTR( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( this->typemap );
 	p_typemap->funcs.fit_to_query( this->typemap, value );
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
@@ -168,7 +196,7 @@ pg_text_enc_record(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 	for( i=0; i<RARRAY_LEN(value); i++){
 		char *ptr1;
 		char *ptr2;
-		int strlen;
+		long strlen;
 		int backslashs;
 		VALUE subint;
 		VALUE entry;
@@ -358,7 +386,7 @@ pg_text_dec_record(t_pg_coder *conv, char *input_line, int len, int _tuple, int
 	char *end_capa_ptr;
 	t_typemap *p_typemap;
 
-	p_typemap = DATA_PTR( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( this->typemap );
 	expected_fields = p_typemap->funcs.fit_to_copy_get( this->typemap );
 
 	/* The received input string will probably have this->nfields fields. */

data/ext/pg_result.c

@@ -107,17 +107,34 @@ pgresult_approx_size(const PGresult *result)
  * GC Mark function
  */
 static void
-pgresult_gc_mark( t_pg_result *this )
+pgresult_gc_mark( void *_this )
 {
+	t_pg_result *this = (t_pg_result *)_this;
 	int i;
 
-	rb_gc_mark( this->connection );
-	rb_gc_mark( this->typemap );
-	rb_gc_mark( this->tuple_hash );
-	rb_gc_mark( this->field_map );
+	rb_gc_mark_movable( this->connection );
+	rb_gc_mark_movable( this->typemap );
+	rb_gc_mark_movable( this->tuple_hash );
+	rb_gc_mark_movable( this->field_map );
 
 	for( i=0; i < this->nfields; i++ ){
-		rb_gc_mark( this->fnames[i] );
+		rb_gc_mark_movable( this->fnames[i] );
+	}
+}
+
+static void
+pgresult_gc_compact( void *_this )
+{
+	t_pg_result *this = (t_pg_result *)_this;
+	int i;
+
+	pg_gc_location( this->connection );
+	pg_gc_location( this->typemap );
+	pg_gc_location( this->tuple_hash );
+	pg_gc_location( this->field_map );
+
+	for( i=0; i < this->nfields; i++ ){
+		pg_gc_location( this->fnames[i] );
 	}
 }
 
@@ -125,8 +142,9 @@ pgresult_gc_mark( t_pg_result *this )
  * GC Free function
  */
 static void
-pgresult_clear( t_pg_result *this )
+pgresult_clear( void *_this )
 {
+	t_pg_result *this = (t_pg_result *)_this;
 	if( this->pgresult && !this->autoclear ){
 		PQclear(this->pgresult);
 #ifdef HAVE_RB_GC_ADJUST_MEMORY_USAGE
@@ -139,15 +157,17 @@ pgresult_clear( t_pg_result *this )
 }
 
 static void
-pgresult_gc_free( t_pg_result *this )
+pgresult_gc_free( void *_this )
 {
+	t_pg_result *this = (t_pg_result *)_this;
 	pgresult_clear( this );
 	xfree(this);
 }
 
 static size_t
-pgresult_memsize( t_pg_result *this )
+pgresult_memsize( const void *_this )
 {
+	const t_pg_result *this = (const t_pg_result *)_this;
 	/* Ideally the memory 'this' is pointing to should be taken into account as well.
 	 * However we don't want to store two memory sizes in t_pg_result just for reporting by ObjectSpace.memsize_of.
 	 */
@@ -155,16 +175,15 @@ pgresult_memsize( t_pg_result *this )
 }
 
 static const rb_data_type_t pgresult_type = {
-	"pg",
+	"PG::Result",
 	{
-		(void (*)(void*))pgresult_gc_mark,
-		(void (*)(void*))pgresult_gc_free,
-		(size_t (*)(const void *))pgresult_memsize,
+		pgresult_gc_mark,
+		pgresult_gc_free,
+		pgresult_memsize,
+		pg_compact_callback(pgresult_gc_compact),
 	},
 	0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
 	RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
 };
 
 /* Needed by sequel_pg gem, do not delete */
@@ -191,7 +210,7 @@ pg_new_result2(PGresult *result, VALUE rb_pgconn)
 	this->pgresult = result;
 	this->connection = rb_pgconn;
 	this->typemap = pg_typemap_all_strings;
-	this->p_typemap = DATA_PTR( this->typemap );
+	this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 	this->nfields = -1;
 	this->tuple_hash = Qnil;
 	this->field_map = Qnil;
@@ -202,11 +221,11 @@ pg_new_result2(PGresult *result, VALUE rb_pgconn)
 		t_pg_connection *p_conn = pg_get_connection(rb_pgconn);
 		VALUE typemap = p_conn->type_map_for_results;
 		/* Type check is done when assigned to PG::Connection. */
-		t_typemap *p_typemap = DATA_PTR(typemap);
+		t_typemap *p_typemap = RTYPEDDATA_DATA(typemap);
 
 		this->enc_idx = p_conn->enc_idx;
 		this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
-		this->p_typemap = DATA_PTR( this->typemap );
+		this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 		this->flags = p_conn->flags;
 	} else {
 		this->enc_idx = rb_locale_encindex();
@@ -270,7 +289,11 @@ pg_new_result_autoclear(PGresult *result, VALUE rb_pgconn)
  * call-seq:
  *    res.check -> nil
  *
- * Raises appropriate exception if PG::Result is in a bad state.
+ * Raises appropriate exception if PG::Result is in a bad state, which is:
+ * * +PGRES_BAD_RESPONSE+
+ * * +PGRES_FATAL_ERROR+
+ * * +PGRES_NONFATAL_ERROR+
+ * * +PGRES_PIPELINE_ABORTED+
  */
 VALUE
 pg_result_check( VALUE self )
@@ -295,10 +318,16 @@ pg_result_check( VALUE self )
 		case PGRES_SINGLE_TUPLE:
 		case PGRES_EMPTY_QUERY:
 		case PGRES_COMMAND_OK:
+#ifdef HAVE_PQENTERPIPELINEMODE
+		case PGRES_PIPELINE_SYNC:
+#endif
 			return self;
 		case PGRES_BAD_RESPONSE:
 		case PGRES_FATAL_ERROR:
 		case PGRES_NONFATAL_ERROR:
+#ifdef HAVE_PQENTERPIPELINEMODE
+		case PGRES_PIPELINE_ABORTED:
+#endif
 			error = rb_str_new2( PQresultErrorMessage(this->pgresult) );
 			break;
 		default:
@@ -353,7 +382,7 @@ pg_result_clear(VALUE self)
  * call-seq:
  *    res.cleared?      -> boolean
  *
- * Returns +true+ if the backend result memory has been free'd.
+ * Returns +true+ if the backend result memory has been freed.
  */
 VALUE
 pgresult_cleared_p( VALUE self )
@@ -367,7 +396,7 @@ pgresult_cleared_p( VALUE self )
  *    res.autoclear?      -> boolean
  *
  * Returns +true+ if the underlying C struct will be cleared at the end of a callback.
- * This applies only to Result objects received by the block to PG::Cinnection#set_notice_receiver .
+ * This applies only to Result objects received by the block to PG::Connection#set_notice_receiver .
  *
  * All other Result objects are automatically cleared by the GC when the object is no longer in use or manually by PG::Result#clear .
  *
@@ -495,6 +524,9 @@ static void pgresult_init_fnames(VALUE self)
  * * +PGRES_NONFATAL_ERROR+
  * * +PGRES_FATAL_ERROR+
  * * +PGRES_COPY_BOTH+
+ * * +PGRES_SINGLE_TUPLE+
+ * * +PGRES_PIPELINE_SYNC+
+ * * +PGRES_PIPELINE_ABORTED+
  */
 static VALUE
 pgresult_result_status(VALUE self)
@@ -506,7 +538,7 @@ pgresult_result_status(VALUE self)
  * call-seq:
  *    res.res_status( status ) -> String
  *
- * Returns the string representation of status +status+.
+ * Returns the string representation of +status+.
  *
 */
 static VALUE
@@ -1003,7 +1035,7 @@ pgresult_cmd_tuples(VALUE self)
 {
 	long n;
 	n = strtol(PQcmdTuples(pgresult_get(self)),NULL, 10);
-	return INT2NUM(n);
+	return LONG2NUM(n);
 }
 
 /*
@@ -1325,14 +1357,11 @@ pgresult_type_map_set(VALUE self, VALUE typemap)
 	t_pg_result *this = pgresult_get_this(self);
 	t_typemap *p_typemap;
 
-	if ( !rb_obj_is_kind_of(typemap, rb_cTypeMap) ) {
-		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::TypeMap)",
-				rb_obj_classname( typemap ) );
-	}
-	Data_Get_Struct(typemap, t_typemap, p_typemap);
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, p_typemap);
 
 	this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
-	this->p_typemap = DATA_PTR( this->typemap );
+	this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 
 	return typemap;
 }
@@ -1531,7 +1560,7 @@ pgresult_stream_each_tuple(VALUE self)
  * It can be set to one of:
  * * +:string+ to use String based field names
  * * +:symbol+ to use Symbol based field names
- * * +:static_symbol+ to use pinned Symbol (can not be garbage collected) - Don't use this, it will probably removed in future.
+ * * +:static_symbol+ to use pinned Symbol (can not be garbage collected) - Don't use this, it will probably be removed in future.
  *
  * The default is retrieved from PG::Connection#field_name_type , which defaults to +:string+ .
  *
@@ -1587,7 +1616,8 @@ init_pg_result()
 	sym_symbol = ID2SYM(rb_intern("symbol"));
 	sym_static_symbol = ID2SYM(rb_intern("static_symbol"));
 
-	rb_cPGresult = rb_define_class_under( rb_mPG, "Result", rb_cData );
+	rb_cPGresult = rb_define_class_under( rb_mPG, "Result", rb_cObject );
+	rb_undef_alloc_func(rb_cPGresult);
 	rb_include_module(rb_cPGresult, rb_mEnumerable);
 	rb_include_module(rb_cPGresult, rb_mPGconstants);
 

data/ext/pg_text_decoder.c

@@ -854,7 +854,7 @@ pg_text_dec_inet(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
 
 		ip_int_native = read_nbo32(dst);
 
-		/* Work around broken IPAddr behavior of convering portion
+		/* Work around broken IPAddr behavior of converting portion
 		   of address after netmask to 0 */
 		switch (mask) {
 			case 0:

data/ext/pg_text_encoder.c

@@ -191,7 +191,7 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 			if (neg)
 				*out++ = '-';
 
-			len = out - start;
+			len = (int)(out - start);
 
 			/* Reverse string. */
 			out--;
@@ -252,7 +252,7 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 		}
 
 		/*
-		 * The following computaion is roughly a conversion kind of
+		 * The following computation is roughly a conversion kind of
 		 *   sprintf( out, "%.16E", dvalue);
 		 */
 
@@ -403,11 +403,11 @@ pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 			*optr++ = hextab[c >> 4];
 			*optr++ = hextab[c & 0xf];
 		}
-		return optr - out;
+		return (int)(optr - out);
 	}else{
 		*intermediate = rb_obj_as_string(value);
 		/* The output starts with "\x" and each character is converted to hex. */
-		return 2 + RSTRING_LEN(*intermediate) * 2;
+		return 2 + RSTRING_LENINT(*intermediate) * 2;
 	}
 }
 
@@ -610,8 +610,8 @@ quote_identifier( VALUE value, VALUE out_string, char *current_out ){
 static char *
 pg_text_enc_array_identifier(VALUE value, VALUE string, char *out, int enc_idx)
 {
-	int i;
-	int nr_elems;
+	long i;
+	long nr_elems;
 
 	Check_Type(value, T_ARRAY);
 	nr_elems = RARRAY_LEN(value);

data/ext/pg_tuple.c

@@ -52,57 +52,83 @@ typedef struct {
 	VALUE values[0];
 } t_pg_tuple;
 
-static inline VALUE
-pg_tuple_get_field_names( t_pg_tuple *this )
+static inline VALUE *
+pg_tuple_get_field_names_ptr( t_pg_tuple *this )
 {
 	if( this->num_fields != (int)RHASH_SIZE(this->field_map) ){
-		return this->values[this->num_fields];
+		return &this->values[this->num_fields];
 	} else {
-		return Qfalse;
+		static VALUE f = Qfalse;
+		return &f;
+	}
+}
+
+static inline VALUE
+pg_tuple_get_field_names( t_pg_tuple *this )
+{
+	return *pg_tuple_get_field_names_ptr(this);
+}
+
+static void
+pg_tuple_gc_mark( void *_this )
+{
+	t_pg_tuple *this = (t_pg_tuple *)_this;
+	int i;
+
+	if( !this ) return;
+	rb_gc_mark_movable( this->result );
+	rb_gc_mark_movable( this->typemap );
+	rb_gc_mark_movable( this->field_map );
+
+	for( i = 0; i < this->num_fields; i++ ){
+		rb_gc_mark_movable( this->values[i] );
 	}
+	rb_gc_mark_movable( pg_tuple_get_field_names(this) );
 }
 
 static void
-pg_tuple_gc_mark( t_pg_tuple *this )
+pg_tuple_gc_compact( void *_this )
 {
+	t_pg_tuple *this = (t_pg_tuple *)_this;
 	int i;
 
 	if( !this ) return;
-	rb_gc_mark( this->result );
-	rb_gc_mark( this->typemap );
-	rb_gc_mark( this->field_map );
+	pg_gc_location( this->result );
+	pg_gc_location( this->typemap );
+	pg_gc_location( this->field_map );
 
 	for( i = 0; i < this->num_fields; i++ ){
-		rb_gc_mark( this->values[i] );
+		pg_gc_location( this->values[i] );
 	}
-	rb_gc_mark( pg_tuple_get_field_names(this) );
+	pg_gc_location( *pg_tuple_get_field_names_ptr(this) );
 }
 
 static void
-pg_tuple_gc_free( t_pg_tuple *this )
+pg_tuple_gc_free( void *_this )
 {
+	t_pg_tuple *this = (t_pg_tuple *)_this;
 	if( !this ) return;
 	xfree(this);
 }
 
 static size_t
-pg_tuple_memsize( t_pg_tuple *this )
+pg_tuple_memsize( const void *_this )
 {
+	const t_pg_tuple *this = (const t_pg_tuple *)_this;
 	if( this==NULL ) return 0;
 	return sizeof(*this) +  sizeof(*this->values) * this->num_fields;
 }
 
 static const rb_data_type_t pg_tuple_type = {
-	"pg",
+	"PG::Tuple",
 	{
-		(void (*)(void*))pg_tuple_gc_mark,
-		(void (*)(void*))pg_tuple_gc_free,
-		(size_t (*)(const void *))pg_tuple_memsize,
+		pg_tuple_gc_mark,
+		pg_tuple_gc_free,
+		pg_tuple_memsize,
+		pg_compact_callback(pg_tuple_gc_compact),
 	},
 	0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
 	RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
 };
 
 /*
@@ -172,7 +198,7 @@ pg_tuple_materialize_field(t_pg_tuple *this, int col)
 	VALUE value = this->values[col];
 
 	if( value == Qundef ){
-		t_typemap *p_typemap = DATA_PTR( this->typemap );
+		t_typemap *p_typemap = RTYPEDDATA_DATA( this->typemap );
 
 		pgresult_get(this->result); /* make sure we have a valid PGresult object */
 		value = p_typemap->funcs.typecast_result_value(p_typemap, this->result, this->row_num, col);
@@ -479,9 +505,9 @@ pg_tuple_load(VALUE self, VALUE a)
 	rb_obj_freeze(field_names);
 	values = RARRAY_AREF(a, 1);
 	Check_Type(values, T_ARRAY);
-	num_fields = RARRAY_LEN(values);
+	num_fields = RARRAY_LENINT(values);
 
-	if (RARRAY_LEN(field_names) != num_fields)
+	if (RARRAY_LENINT(field_names) != num_fields)
 		rb_raise(rb_eTypeError, "different number of fields and values");
 
 	field_map = rb_hash_new();