pg 1.0.0 → 1.5.4

data/ext/pg_type_map_all_strings.c

@@ -1,6 +1,6 @@
 /*
  * pg_type_map_all_strings.c - PG::TypeMapAllStrings class extension
- * $Id: pg_type_map_all_strings.c,v c53f993a4254 2014/12/12 21:57:29 lars $
+ * $Id$
  *
  * This is the default typemap.
  *
@@ -8,6 +8,19 @@
 
 #include "pg.h"
 
+static const rb_data_type_t pg_tmas_type = {
+	"PG::TypeMapAllStrings",
+	{
+		pg_typemap_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_typemap_memsize,
+		pg_compact_callback(pg_typemap_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 VALUE rb_cTypeMapAllStrings;
 VALUE pg_typemap_all_strings;
 
@@ -33,9 +46,9 @@ pg_tmas_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 	len = PQgetlength( p_result->pgresult, tuple, field );
 
 	if ( 0 == PQfformat(p_result->pgresult, field) ) {
-		ret = pg_text_dec_string(NULL, val, len, tuple, field, ENCODING_GET(result));
+		ret = pg_text_dec_string(NULL, val, len, tuple, field, p_result->enc_idx);
 	} else {
-		ret = pg_bin_dec_bytea(NULL, val, len, tuple, field, ENCODING_GET(result));
+		ret = pg_bin_dec_bytea(NULL, val, len, tuple, field, p_result->enc_idx);
 	}
 
 	return ret;
@@ -63,6 +76,7 @@ pg_tmas_fit_to_copy_get( VALUE self )
 static VALUE
 pg_tmas_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
 {
+	rb_str_modify(field_str);
 	if( format == 0 ){
 		PG_ENCODING_SET_NOCHECK( field_str, enc_idx );
 	} else {
@@ -77,7 +91,7 @@ pg_tmas_s_allocate( VALUE klass )
 	t_typemap *this;
 	VALUE self;
 
-	self = Data_Make_Struct( klass, t_typemap, NULL, -1, this );
+	self = TypedData_Make_Struct( klass, t_typemap, &pg_tmas_type, this );
 
 	this->funcs.fit_to_result = pg_tmas_fit_to_result;
 	this->funcs.fit_to_query = pg_tmas_fit_to_query;
@@ -91,7 +105,7 @@ pg_tmas_s_allocate( VALUE klass )
 
 
 void
-init_pg_type_map_all_strings()
+init_pg_type_map_all_strings(void)
 {
 	/*
 	 * Document-class: PG::TypeMapAllStrings < PG::TypeMap
@@ -99,7 +113,7 @@ init_pg_type_map_all_strings()
 	 * This type map casts all values received from the database server to Strings
 	 * and sends all values to the server after conversion to String by +#to_s+ .
 	 * That means, it is hard coded to PG::TextEncoder::String for value encoding
-	 * and to PG::TextDecoder::String for text format respectivly PG::BinaryDecoder::Bytea
+	 * and to PG::TextDecoder::String for text format respectively PG::BinaryDecoder::Bytea
 	 * for binary format received from the server.
 	 *
 	 * It is suitable for type casting query bind parameters, result values and
@@ -111,6 +125,6 @@ init_pg_type_map_all_strings()
 	rb_cTypeMapAllStrings = rb_define_class_under( rb_mPG, "TypeMapAllStrings", rb_cTypeMap );
 	rb_define_alloc_func( rb_cTypeMapAllStrings, pg_tmas_s_allocate );
 
-	pg_typemap_all_strings = rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 );
+	pg_typemap_all_strings = rb_obj_freeze( rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 ));
 	rb_gc_register_address( &pg_typemap_all_strings );
 }

data/ext/pg_type_map_by_class.c

@@ -1,6 +1,6 @@
 /*
  * pg_type_map_by_class.c - PG::TypeMapByClass class extension
- * $Id: pg_type_map_by_class.c,v eeb8a82c5328 2014/11/10 19:34:02 lars $
+ * $Id$
  *
  * This type map can be used to select value encoders based on the class
  * of the given value to be send.
@@ -10,7 +10,6 @@
 #include "pg.h"
 
 static VALUE rb_cTypeMapByClass;
-static ID s_id_ancestors;
 
 typedef struct {
 	t_typemap typemap;
@@ -28,7 +27,7 @@ typedef struct {
  * We use 8 Bits of the klass object id as index to a 256 entry cache.
  * This avoids full lookups in most cases.
  */
-#define CACHE_LOOKUP(this, klass) ( &this->cache_row[(klass >> 8) & 0xff] )
+#define CACHE_LOOKUP(this, klass) ( &this->cache_row[(((unsigned long)klass) >> 8) & 0xff] )
 
 
 static t_pg_coder *
@@ -48,7 +47,7 @@ pg_tmbk_lookup_klass(t_tmbk *this, VALUE klass, VALUE param_value)
 
 		if( NIL_P(obj) ){
 			int i;
-			VALUE ancestors = rb_funcall( klass, s_id_ancestors, 0 );
+			VALUE ancestors = rb_mod_ancestors( klass );
 
 			Check_Type( ancestors, T_ARRAY );
 			/* Don't look at the first element, it's expected to equal klass. */
@@ -63,10 +62,10 @@ pg_tmbk_lookup_klass(t_tmbk *this, VALUE klass, VALUE param_value)
 		if(NIL_P(obj)){
 			p_coder = NULL;
 		}else if(rb_obj_is_kind_of(obj, rb_cPG_Coder)){
-			Data_Get_Struct(obj, t_pg_coder, p_coder);
+			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
 		}else{
 			if( RB_TYPE_P(obj, T_SYMBOL) ){
-				/* A Proc object (or something that responds to #call). */
+				/* A Symbol: Call the method with this name. */
 				obj = rb_funcall(this->self, SYM2ID(obj), 1, param_value);
 			}else{
 				/* A Proc object (or something that responds to #call). */
@@ -75,11 +74,9 @@ pg_tmbk_lookup_klass(t_tmbk *this, VALUE klass, VALUE param_value)
 
 			if( NIL_P(obj) ){
 				p_coder = NULL;
-			}else if( rb_obj_is_kind_of(obj, rb_cPG_Coder) ){
-				Data_Get_Struct(obj, t_pg_coder, p_coder);
 			}else{
-				rb_raise(rb_eTypeError, "argument has invalid type %s (should be nil or some kind of PG::Coder)",
-							rb_obj_classname( obj ));
+				/* Check retrieved coder type */
+				TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
 			}
 
 			/* We can not cache coders retrieved by ruby code, because we can not anticipate
@@ -104,7 +101,7 @@ pg_tmbk_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field
   p_coder = pg_tmbk_lookup_klass( this, rb_obj_class(param_value), param_value );
 
 	if( !p_coder ){
-		t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+		t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 		return default_tm->funcs.typecast_query_param( default_tm, param_value, field );
 	}
 
@@ -114,42 +111,76 @@ pg_tmbk_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field
 static VALUE
 pg_tmbk_fit_to_query( VALUE self, VALUE params )
 {
-	t_tmbk *this = (t_tmbk *)DATA_PTR(self);
+	t_tmbk *this = (t_tmbk *)RTYPEDDATA_DATA(self);
 	/* Nothing to check at this typemap, but ensure that the default type map fits. */
-	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
 	return self;
 }
 
 static void
-pg_tmbk_mark( t_tmbk *this )
+pg_tmbk_mark( void *_this )
+{
+	t_tmbk *this = (t_tmbk *)_this;
+	pg_typemap_mark(&this->typemap);
+	rb_gc_mark_movable(this->klass_to_coder);
+	rb_gc_mark_movable(this->self);
+}
+
+static size_t
+pg_tmbk_memsize( const void *_this )
 {
-	rb_gc_mark(this->typemap.default_typemap);
-	rb_gc_mark(this->klass_to_coder);
-	/* All coders are in the Hash, so no need to mark the cache. */
+	const t_tmbk *this = (const t_tmbk *)_this;
+	return sizeof(*this);
 }
 
+static void
+pg_tmbk_compact(void *ptr)
+{
+	t_tmbk *this = (t_tmbk *)ptr;
+
+	pg_typemap_compact(&this->typemap);
+	pg_gc_location(this->klass_to_coder);
+	pg_gc_location(this->self);
+
+	/* Clear the cache, to be safe from changes of klass VALUE by GC.compact. */
+	memset(&this->cache_row, 0, sizeof(this->cache_row));
+}
+
+static const rb_data_type_t pg_tmbk_type = {
+	"PG::TypeMapByClass",
+	{
+		pg_tmbk_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_tmbk_memsize,
+		pg_compact_callback(pg_tmbk_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 static VALUE
 pg_tmbk_s_allocate( VALUE klass )
 {
 	t_tmbk *this;
 	VALUE self;
 
-	self = Data_Make_Struct( klass, t_tmbk, pg_tmbk_mark, -1, this );
+	self = TypedData_Make_Struct( klass, t_tmbk, &pg_tmbk_type, this );
 	this->typemap.funcs.fit_to_result = pg_typemap_fit_to_result;
 	this->typemap.funcs.fit_to_query = pg_tmbk_fit_to_query;
 	this->typemap.funcs.fit_to_copy_get = pg_typemap_fit_to_copy_get;
 	this->typemap.funcs.typecast_result_value = pg_typemap_result_value;
 	this->typemap.funcs.typecast_query_param = pg_tmbk_typecast_query_param;
 	this->typemap.funcs.typecast_copy_get = pg_typemap_typecast_copy_get;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 
 	/* We need to store self in the this-struct, because pg_tmbk_typecast_query_param(),
 	 * is called with the this-pointer only. */
 	this->self = self;
-	this->klass_to_coder = rb_hash_new();
+	RB_OBJ_WRITE(self, &this->klass_to_coder, rb_hash_new());
 
-	/* The cache is properly initialized by Data_Make_Struct(). */
+	/* The cache is properly initialized by TypedData_Make_Struct(). */
 
 	return self;
 }
@@ -172,7 +203,9 @@ pg_tmbk_s_allocate( VALUE klass )
 static VALUE
 pg_tmbk_aset( VALUE self, VALUE klass, VALUE coder )
 {
-	t_tmbk *this = DATA_PTR( self );
+	t_tmbk *this = RTYPEDDATA_DATA( self );
+
+	rb_check_frozen(self);
 
 	if(NIL_P(coder)){
 		rb_hash_delete( this->klass_to_coder, klass );
@@ -196,7 +229,7 @@ pg_tmbk_aset( VALUE self, VALUE klass, VALUE coder )
 static VALUE
 pg_tmbk_aref( VALUE self, VALUE klass )
 {
-	t_tmbk *this = DATA_PTR( self );
+	t_tmbk *this = RTYPEDDATA_DATA( self );
 
 	return rb_hash_lookup(this->klass_to_coder, klass);
 }
@@ -210,16 +243,14 @@ pg_tmbk_aref( VALUE self, VALUE klass )
 static VALUE
 pg_tmbk_coders( VALUE self )
 {
-	t_tmbk *this = DATA_PTR( self );
+	t_tmbk *this = RTYPEDDATA_DATA( self );
 
 	return rb_obj_freeze(rb_hash_dup(this->klass_to_coder));
 }
 
 void
-init_pg_type_map_by_class()
+init_pg_type_map_by_class(void)
 {
-	s_id_ancestors = rb_intern("ancestors");
-
 	/*
 	 * Document-class: PG::TypeMapByClass < PG::TypeMap
 	 *
@@ -235,5 +266,6 @@ init_pg_type_map_by_class()
 	rb_define_method( rb_cTypeMapByClass, "[]=", pg_tmbk_aset, 2 );
 	rb_define_method( rb_cTypeMapByClass, "[]", pg_tmbk_aref, 1 );
 	rb_define_method( rb_cTypeMapByClass, "coders", pg_tmbk_coders, 0 );
+	/* rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable"); */
 	rb_include_module( rb_cTypeMapByClass, rb_mDefaultTypeMappable );
 }

data/ext/pg_type_map_by_column.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map_by_column.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
+ * $Id$
  *
  */
 
@@ -16,7 +16,7 @@ static VALUE
 pg_tmbc_fit_to_result( VALUE self, VALUE result )
 {
 	int nfields;
-	t_tmbc *this = DATA_PTR( self );
+	t_tmbc *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 	VALUE sub_typemap;
 
@@ -26,8 +26,8 @@ pg_tmbc_fit_to_result( VALUE self, VALUE result )
 				nfields, this->nfields );
 	}
 
-	/* Ensure that the default type map fits equaly. */
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	sub_typemap = default_tm->funcs.fit_to_result( this->typemap.default_typemap, result );
 
 	/* Did the default type return the same object ? */
@@ -42,7 +42,7 @@ pg_tmbc_fit_to_result( VALUE self, VALUE result )
 
 		memcpy( p_new_typemap, this, struct_size );
 		p_new_typemap->typemap.default_typemap = sub_typemap;
-		DATA_PTR(new_typemap) = p_new_typemap;
+		RTYPEDDATA_DATA(new_typemap) = p_new_typemap;
 		return new_typemap;
 	}
 }
@@ -51,7 +51,7 @@ static VALUE
 pg_tmbc_fit_to_query( VALUE self, VALUE params )
 {
 	int nfields;
-	t_tmbc *this = DATA_PTR( self );
+	t_tmbc *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 
 	nfields = (int)RARRAY_LEN( params );
@@ -60,8 +60,8 @@ pg_tmbc_fit_to_query( VALUE self, VALUE params )
 				nfields, this->nfields );
 	}
 
-	/* Ensure that the default type map fits equaly. */
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
 
 	return self;
@@ -70,10 +70,10 @@ pg_tmbc_fit_to_query( VALUE self, VALUE params )
 static int
 pg_tmbc_fit_to_copy_get( VALUE self )
 {
-	t_tmbc *this = DATA_PTR( self );
+	t_tmbc *this = RTYPEDDATA_DATA( self );
 
-	/* Ensure that the default type map fits equaly. */
-	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	default_tm->funcs.fit_to_copy_get( this->typemap.default_typemap );
 
 	return this->nfields;
@@ -99,15 +99,15 @@ pg_tmbc_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 		int len = PQgetlength( p_result->pgresult, tuple, field );
 
 		if( p_coder->dec_func ){
-			return p_coder->dec_func(p_coder, val, len, tuple, field, ENCODING_GET(result));
+			return p_coder->dec_func(p_coder, val, len, tuple, field, p_result->enc_idx);
 		} else {
 			t_pg_coder_dec_func dec_func;
 			dec_func = pg_coder_dec_func( p_coder, PQfformat(p_result->pgresult, field) );
-			return dec_func(p_coder, val, len, tuple, field, ENCODING_GET(result));
+			return dec_func(p_coder, val, len, tuple, field, p_result->enc_idx);
 		}
 	}
 
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	return default_tm->funcs.typecast_result_value( default_tm, result, tuple, field );
 }
 
@@ -120,7 +120,7 @@ pg_tmbc_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field
 	t_pg_coder *p_coder = this->convs[field].cconv;
 
 	if( !p_coder ){
-		t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+		t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 		return default_tm->funcs.typecast_query_param( default_tm, param_value, field );
 	}
 
@@ -142,7 +142,7 @@ pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, i
 	p_coder = this->convs[fieldno].cconv;
 
 	if( !p_coder ){
-		t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+		t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 		return default_tm->funcs.typecast_copy_get( default_tm, field_str, fieldno, format, enc_idx );
 	}
 
@@ -150,15 +150,17 @@ pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, i
 
 	/* Is it a pure String conversion? Then we can directly send field_str to the user. */
 	if( dec_func == pg_text_dec_string ){
+		rb_str_modify(field_str);
 		PG_ENCODING_SET_NOCHECK( field_str, enc_idx );
 		return field_str;
 	}
 	if( dec_func == pg_bin_dec_bytea ){
+		rb_str_modify(field_str);
 		PG_ENCODING_SET_NOCHECK( field_str, rb_ascii8bit_encindex() );
 		return field_str;
 	}
 
-	return dec_func( p_coder, RSTRING_PTR(field_str), RSTRING_LEN(field_str), 0, fieldno, enc_idx );
+	return dec_func( p_coder, RSTRING_PTR(field_str), RSTRING_LENINT(field_str), 0, fieldno, enc_idx );
 }
 
 const struct pg_typemap_funcs pg_tmbc_funcs = {
@@ -171,38 +173,77 @@ const struct pg_typemap_funcs pg_tmbc_funcs = {
 };
 
 static void
-pg_tmbc_mark( t_tmbc *this )
+pg_tmbc_mark( void *_this )
 {
+	t_tmbc *this = (t_tmbc *)_this;
 	int i;
 
 	/* allocated but not initialized ? */
 	if( this == (t_tmbc *)&pg_typemap_funcs ) return;
 
-	rb_gc_mark(this->typemap.default_typemap);
+	pg_typemap_mark(&this->typemap);
 	for( i=0; i<this->nfields; i++){
 		t_pg_coder *p_coder = this->convs[i].cconv;
 		if( p_coder )
-			rb_gc_mark(p_coder->coder_obj);
+			rb_gc_mark_movable(p_coder->coder_obj);
+	}
+}
+
+static size_t
+pg_tmbc_memsize( const void *_this )
+{
+	const t_tmbc *this = (const t_tmbc *)_this;
+	return sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * this->nfields;
+}
+
+static void
+pg_tmbc_compact( void *_this )
+{
+	t_tmbc *this = (t_tmbc *)_this;
+	int i;
+
+	/* allocated but not initialized ? */
+	if( this == (t_tmbc *)&pg_typemap_funcs ) return;
+
+	pg_typemap_compact(&this->typemap);
+	for( i=0; i<this->nfields; i++){
+		t_pg_coder *p_coder = this->convs[i].cconv;
+		if( p_coder )
+			pg_gc_location(p_coder->coder_obj);
 	}
 }
 
 static void
-pg_tmbc_free( t_tmbc *this )
+pg_tmbc_free( void *_this )
 {
+	t_tmbc *this = (t_tmbc *)_this;
 	/* allocated but not initialized ? */
 	if( this == (t_tmbc *)&pg_typemap_funcs ) return;
 	xfree( this );
 }
 
+static const rb_data_type_t pg_tmbc_type = {
+	"PG::TypeMapByColumn",
+	{
+		pg_tmbc_mark,
+		pg_tmbc_free,
+		pg_tmbc_memsize,
+		pg_compact_callback(pg_tmbc_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 static VALUE
 pg_tmbc_s_allocate( VALUE klass )
 {
 	/* Use pg_typemap_funcs as interim struct until #initialize is called. */
-	return Data_Wrap_Struct( klass, pg_tmbc_mark, pg_tmbc_free, (t_tmbc *)&pg_typemap_funcs );
+	return TypedData_Wrap_Struct( klass, &pg_tmbc_type, (t_tmbc *)&pg_typemap_funcs );
 }
 
 VALUE
-pg_tmbc_allocate()
+pg_tmbc_allocate(void)
 {
 	return pg_tmbc_s_allocate(rb_cTypeMapByColumn);
 }
@@ -221,19 +262,19 @@ pg_tmbc_allocate()
 static VALUE
 pg_tmbc_init(VALUE self, VALUE conv_ary)
 {
-	int i;
+	long i;
 	t_tmbc *this;
 	int conv_ary_len;
 
-	Check_Type(self, T_DATA);
+	rb_check_frozen(self);
 	Check_Type(conv_ary, T_ARRAY);
-	conv_ary_len = RARRAY_LEN(conv_ary);
+	conv_ary_len = RARRAY_LENINT(conv_ary);
 	this = xmalloc(sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * conv_ary_len);
 	/* Set nfields to 0 at first, so that GC mark function doesn't access uninitialized memory. */
 	this->nfields = 0;
 	this->typemap.funcs = pg_tmbc_funcs;
-	this->typemap.default_typemap = pg_typemap_all_strings;
-	DATA_PTR(self) = this;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
+	RTYPEDDATA_DATA(self) = this;
 
 	for(i=0; i<conv_ary_len; i++)
 	{
@@ -242,11 +283,12 @@ pg_tmbc_init(VALUE self, VALUE conv_ary)
 		if( obj == Qnil ){
 			/* no type cast */
 			this->convs[i].cconv = NULL;
-		} else if( rb_obj_is_kind_of(obj, rb_cPG_Coder) ){
-			Data_Get_Struct(obj, t_pg_coder, this->convs[i].cconv);
 		} else {
-			rb_raise(rb_eArgError, "argument %d has invalid type %s (should be nil or some kind of PG::Coder)",
-							 i+1, rb_obj_classname( obj ));
+			t_pg_coder *p_coder;
+			/* Check argument type and store the coder pointer */
+			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
+			RB_OBJ_WRITTEN(self, Qnil, p_coder->coder_obj);
+			this->convs[i].cconv = p_coder;
 		}
 	}
 
@@ -266,7 +308,7 @@ static VALUE
 pg_tmbc_coders(VALUE self)
 {
 	int i;
-	t_tmbc *this = DATA_PTR( self );
+	t_tmbc *this = RTYPEDDATA_DATA( self );
 	VALUE ary_coders = rb_ary_new();
 
 	for( i=0; i<this->nfields; i++){
@@ -282,7 +324,7 @@ pg_tmbc_coders(VALUE self)
 }
 
 void
-init_pg_type_map_by_column()
+init_pg_type_map_by_column(void)
 {
 	s_id_decode = rb_intern("decode");
 	s_id_encode = rb_intern("encode");
@@ -292,13 +334,13 @@ init_pg_type_map_by_column()
 	 *
 	 * This type map casts values by a coder assigned per field/column.
 	 *
-	 * Each PG:TypeMapByColumn has a fixed list of either encoders or decoders,
-	 * that is defined at #new . A type map with encoders is usable for type casting
+	 * Each PG::TypeMapByColumn has a fixed list of either encoders or decoders,
+	 * that is defined at TypeMapByColumn.new . A type map with encoders is usable for type casting
 	 * query bind parameters and COPY data for PG::Connection#put_copy_data .
 	 * A type map with decoders is usable for type casting of result values and
 	 * COPY data from PG::Connection#get_copy_data .
 	 *
-	 * PG::TypeMapByColumns are in particular useful in conjunction with prepared statements,
+	 * PG::TypeMapByColumn objects are in particular useful in conjunction with prepared statements,
 	 * since they can be cached alongside with the statement handle.
 	 *
 	 * This type map strategy is also used internally by PG::TypeMapByOid, when the
@@ -308,5 +350,6 @@ init_pg_type_map_by_column()
 	rb_define_alloc_func( rb_cTypeMapByColumn, pg_tmbc_s_allocate );
 	rb_define_method( rb_cTypeMapByColumn, "initialize", pg_tmbc_init, 1 );
 	rb_define_method( rb_cTypeMapByColumn, "coders", pg_tmbc_coders, 0 );
+	/* rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable"); */
 	rb_include_module( rb_cTypeMapByColumn, rb_mDefaultTypeMappable );
 }