pg 1.2.3 → 1.6.1

data/ext/pg_type_map_by_column.c

@@ -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,17 +51,18 @@ 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;
 
+	Check_Type(params, T_ARRAY);
 	nfields = (int)RARRAY_LEN( params );
 	if ( this->nfields != nfields ) {
 		rb_raise( rb_eArgError, "number of result fields (%d) does not match number of mapped columns (%d)",
 				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 +71,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;
@@ -107,7 +108,7 @@ pg_tmbc_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 		}
 	}
 
-	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 +121,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 +143,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 +151,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 +174,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_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 +263,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 +284,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 +309,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 +325,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");

data/ext/pg_type_map_by_mri_type.c

@@ -71,16 +71,12 @@ pg_tmbmt_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int fiel
 
 		obj = rb_funcall(ask_for_coder, rb_intern("call"), 1, param_value);
 
-		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 %d has invalid type %s (should be nil or some kind of PG::Coder)",
-						field+1, rb_obj_classname( obj ));
-		}
+		/* Check argument type and store the coder pointer */
+		TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
 	}
 
 	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 );
 	}
 
@@ -90,24 +86,57 @@ pg_tmbmt_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int fiel
 static VALUE
 pg_tmbmt_fit_to_query( VALUE self, VALUE params )
 {
-	t_tmbmt *this = (t_tmbmt *)DATA_PTR(self);
+	t_tmbmt *this = (t_tmbmt *)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;
 }
 
 #define GC_MARK_AS_USED(type) \
-	rb_gc_mark( this->coders.ask_##type ); \
-	rb_gc_mark( this->coders.coder_obj_##type );
+	rb_gc_mark_movable( this->coders.ask_##type ); \
+	rb_gc_mark_movable( this->coders.coder_obj_##type );
 
 static void
-pg_tmbmt_mark( t_tmbmt *this )
+pg_tmbmt_mark( void *_this )
 {
-	rb_gc_mark(this->typemap.default_typemap);
+	t_tmbmt *this = (t_tmbmt *)_this;
+	pg_typemap_mark(&this->typemap);
 	FOR_EACH_MRI_TYPE( GC_MARK_AS_USED );
 }
 
+static size_t
+pg_tmbmt_memsize( const void *_this )
+{
+	const t_tmbmt *this = (const t_tmbmt *)_this;
+	return sizeof(*this);
+}
+
+#define GC_COMPACT(type) \
+	pg_gc_location( this->coders.ask_##type ); \
+	pg_gc_location( this->coders.coder_obj_##type );
+
+static void
+pg_tmbmt_compact( void *_this )
+{
+	t_tmbmt *this = (t_tmbmt *)_this;
+	pg_typemap_compact(&this->typemap);
+	FOR_EACH_MRI_TYPE( GC_COMPACT );
+}
+
+static const rb_data_type_t pg_tmbmt_type = {
+	"PG::TypeMapByMriType",
+	{
+		pg_tmbmt_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_tmbmt_memsize,
+		pg_tmbmt_compact,
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 #define INIT_VARIABLES(type) \
 	this->coders.coder_##type = NULL; \
 	this->coders.ask_##type = Qnil; \
@@ -119,7 +148,7 @@ pg_tmbmt_s_allocate( VALUE klass )
 	t_tmbmt *this;
 	VALUE self;
 
-	self = Data_Make_Struct( klass, t_tmbmt, pg_tmbmt_mark, -1, this );
+	self = TypedData_Make_Struct( klass, t_tmbmt, &pg_tmbmt_type, this );
 	this->typemap.funcs.fit_to_result = pg_typemap_fit_to_result;
 	this->typemap.funcs.fit_to_query = pg_tmbmt_fit_to_query;
 	this->typemap.funcs.fit_to_copy_get = pg_typemap_fit_to_copy_get;
@@ -140,7 +169,7 @@ pg_tmbmt_s_allocate( VALUE klass )
 			this->coders.coder_##type = NULL; \
 			this->coders.ask_##type = Qnil; \
 		}else if(rb_obj_is_kind_of(coder, rb_cPG_Coder)){ \
-			Data_Get_Struct(coder, t_pg_coder, this->coders.coder_##type); \
+			TypedData_Get_Struct(coder, t_pg_coder, &pg_coder_type, this->coders.coder_##type); \
 			this->coders.ask_##type = Qnil; \
 		}else if(RB_TYPE_P(coder, T_SYMBOL)){ \
 			this->coders.coder_##type = NULL; \
@@ -188,7 +217,7 @@ pg_tmbmt_s_allocate( VALUE klass )
 static VALUE
 pg_tmbmt_aset( VALUE self, VALUE mri_type, VALUE coder )
 {
-	t_tmbmt *this = DATA_PTR( self );
+	t_tmbmt *this = RTYPEDDATA_DATA( self );
 	char *p_mri_type;
 
 	p_mri_type = StringValueCStr(mri_type);
@@ -220,7 +249,7 @@ static VALUE
 pg_tmbmt_aref( VALUE self, VALUE mri_type )
 {
 	VALUE coder;
-	t_tmbmt *this = DATA_PTR( self );
+	t_tmbmt *this = RTYPEDDATA_DATA( self );
 	char *p_mri_type;
 
 	p_mri_type = StringValueCStr(mri_type);
@@ -248,7 +277,7 @@ pg_tmbmt_aref( VALUE self, VALUE mri_type )
 static VALUE
 pg_tmbmt_coders( VALUE self )
 {
-	t_tmbmt *this = DATA_PTR( self );
+	t_tmbmt *this = RTYPEDDATA_DATA( self );
 	VALUE hash_coders = rb_hash_new();
 
 	FOR_EACH_MRI_TYPE( ADD_TO_HASH );
@@ -257,7 +286,7 @@ pg_tmbmt_coders( VALUE self )
 }
 
 void
-init_pg_type_map_by_mri_type()
+init_pg_type_map_by_mri_type(void)
 {
 	/*
 	 * Document-class: PG::TypeMapByMriType < PG::TypeMap

data/ext/pg_type_map_by_oid.c

@@ -46,7 +46,7 @@ pg_tmbo_lookup_oid(t_tmbo *this, int format, Oid oid)
 	} else {
 		VALUE obj = rb_hash_lookup( this->format[format].oid_to_coder, UINT2NUM( oid ));
 		/* obj must be nil or some kind of PG::Coder, this is checked at insertion */
-		conv = NIL_P(obj) ? NULL : DATA_PTR(obj);
+		conv = NIL_P(obj) ? NULL : RTYPEDDATA_DATA(obj);
 		/* Write the retrieved coder to the cache */
 		p_ce->oid = oid;
 		p_ce->p_coder = conv;
@@ -70,7 +70,7 @@ pg_tmbo_build_type_map_for_result2( t_tmbo *this, PGresult *pgresult )
 	p_colmap->typemap.default_typemap = pg_typemap_all_strings;
 
 	colmap = pg_tmbc_allocate();
-	DATA_PTR(colmap) = p_colmap;
+	RTYPEDDATA_DATA(colmap) = p_colmap;
 
 	for(i=0; i<nfields; i++)
 	{
@@ -113,18 +113,18 @@ pg_tmbo_result_value(t_typemap *p_typemap, VALUE result, int tuple, int field)
 		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 );
 }
 
 static VALUE
 pg_tmbo_fit_to_result( VALUE self, VALUE result )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	PGresult *pgresult = pgresult_get( result );
 
-	/* 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 );
 	VALUE sub_typemap = default_tm->funcs.fit_to_result( this->typemap.default_typemap, result );
 
 	if( PQntuples( pgresult ) <= this->max_rows_for_online_lookup ){
@@ -137,7 +137,7 @@ pg_tmbo_fit_to_result( VALUE self, VALUE result )
 			/* The default type map built a new object, so we need to propagate it
 			 * and build a copy of this type map. */
 			VALUE new_typemap = pg_tmbo_s_allocate( rb_cTypeMapByOid );
-			t_tmbo *p_new_typemap = DATA_PTR(new_typemap);
+			t_tmbo *p_new_typemap = RTYPEDDATA_DATA(new_typemap);
 			*p_new_typemap = *this;
 			p_new_typemap->typemap.default_typemap = sub_typemap;
 			return new_typemap;
@@ -147,23 +147,56 @@ pg_tmbo_fit_to_result( VALUE self, VALUE result )
 		 * uses a fast array lookup.
 		 */
 		VALUE new_typemap = pg_tmbo_build_type_map_for_result2( this, pgresult );
-		t_tmbo *p_new_typemap = DATA_PTR(new_typemap);
+		t_tmbo *p_new_typemap = RTYPEDDATA_DATA(new_typemap);
 		p_new_typemap->typemap.default_typemap = sub_typemap;
 		return new_typemap;
 	}
 }
 
 static void
-pg_tmbo_mark( t_tmbo *this )
+pg_tmbo_mark( void *_this )
 {
+	t_tmbo *this = (t_tmbo *)_this;
 	int i;
 
-	rb_gc_mark(this->typemap.default_typemap);
+	pg_typemap_mark(&this->typemap);
 	for( i=0; i<2; i++){
-		rb_gc_mark(this->format[i].oid_to_coder);
+		rb_gc_mark_movable(this->format[i].oid_to_coder);
 	}
 }
 
+static size_t
+pg_tmbo_memsize( const void *_this )
+{
+	const t_tmbo *this = (const t_tmbo *)_this;
+	return sizeof(*this);
+}
+
+static void
+pg_tmbo_compact( void *_this )
+{
+	t_tmbo *this = (t_tmbo *)_this;
+	int i;
+
+	pg_typemap_compact(&this->typemap);
+	for( i=0; i<2; i++){
+		pg_gc_location(this->format[i].oid_to_coder);
+	}
+}
+
+static const rb_data_type_t pg_tmbo_type = {
+	"PG::TypeMapByOid",
+	{
+		pg_tmbo_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_tmbo_memsize,
+		pg_tmbo_compact,
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 static VALUE
 pg_tmbo_s_allocate( VALUE klass )
 {
@@ -171,7 +204,7 @@ pg_tmbo_s_allocate( VALUE klass )
 	VALUE self;
 	int i;
 
-	self = Data_Make_Struct( klass, t_tmbo, pg_tmbo_mark, -1, this );
+	self = TypedData_Make_Struct( klass, t_tmbo, &pg_tmbo_type, this );
 
 	this->typemap.funcs.fit_to_result = pg_tmbo_fit_to_result;
 	this->typemap.funcs.fit_to_query = pg_typemap_fit_to_query;
@@ -179,11 +212,11 @@ pg_tmbo_s_allocate( VALUE klass )
 	this->typemap.funcs.typecast_result_value = pg_tmbo_result_value;
 	this->typemap.funcs.typecast_query_param = pg_typemap_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);
 	this->max_rows_for_online_lookup = 10;
 
 	for( i=0; i<2; i++){
-		this->format[i].oid_to_coder = rb_hash_new();
+		RB_OBJ_WRITE(self, &this->format[i].oid_to_coder, rb_hash_new());
 	}
 
 	return self;
@@ -205,15 +238,12 @@ static VALUE
 pg_tmbo_add_coder( VALUE self, VALUE coder )
 {
 	VALUE hash;
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	t_pg_coder *p_coder;
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
-	if( !rb_obj_is_kind_of(coder, rb_cPG_Coder) )
-		rb_raise(rb_eArgError, "invalid type %s (should be some kind of PG::Coder)",
-							rb_obj_classname( coder ));
-
-	Data_Get_Struct(coder, t_pg_coder, p_coder);
+	rb_check_frozen(self);
+	TypedData_Get_Struct(coder, t_pg_coder, &pg_coder_type, p_coder);
 
 	if( p_coder->format < 0 || p_coder->format > 1 )
 		rb_raise(rb_eArgError, "invalid format code %d", p_coder->format);
@@ -243,10 +273,11 @@ pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
 {
 	VALUE hash;
 	VALUE coder;
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	int i_format = NUM2INT(format);
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
+	rb_check_frozen(self);
 	if( i_format < 0 || i_format > 1 )
 		rb_raise(rb_eArgError, "invalid format code %d", i_format);
 
@@ -269,7 +300,7 @@ pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
 static VALUE
 pg_tmbo_coders( VALUE self )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 
 	return rb_ary_concat(
 			rb_funcall(this->format[0].oid_to_coder, rb_intern("values"), 0),
@@ -284,11 +315,14 @@ pg_tmbo_coders( VALUE self )
  * The type map will do Hash lookups for each result value, if the number of rows
  * is below or equal +number+.
  *
+ * Default is 10.
+ *
  */
 static VALUE
 pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
+	rb_check_frozen(self);
 	this->max_rows_for_online_lookup = NUM2INT(value);
 	return value;
 }
@@ -300,7 +334,7 @@ pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
 static VALUE
 pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	return INT2NUM(this->max_rows_for_online_lookup);
 }
 
@@ -309,13 +343,13 @@ pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
  *    typemap.build_column_map( result )
  *
  * This builds a PG::TypeMapByColumn that fits to the given PG::Result object
- * based on it's type OIDs.
+ * based on it's type OIDs and binary/text format.
  *
  */
 static VALUE
 pg_tmbo_build_column_map( VALUE self, VALUE result )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 
 	if ( !rb_obj_is_kind_of(result, rb_cPGresult) ) {
 		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::Result)",
@@ -327,7 +361,7 @@ pg_tmbo_build_column_map( VALUE self, VALUE result )
 
 
 void
-init_pg_type_map_by_oid()
+init_pg_type_map_by_oid(void)
 {
 	s_id_decode = rb_intern("decode");