pg 1.2.3 → 1.4.4

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);
@@ -775,7 +775,7 @@ pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedi
 
 
 void
-init_pg_text_encoder()
+init_pg_text_encoder(void)
 {
 	s_id_encode = rb_intern("encode");
 	s_id_to_i = rb_intern("to_i");

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);
@@ -445,10 +471,7 @@ pg_tuple_dump(VALUE self)
 	values = rb_ary_new4(this->num_fields, &this->values[0]);
 	a = rb_ary_new3(2, field_names, values);
 
-	if (FL_TEST(self, FL_EXIVAR)) {
-		rb_copy_generic_ivar(a, self);
-		FL_SET(a, FL_EXIVAR);
-	}
+        rb_copy_generic_ivar(a, self);
 
 	return a;
 }
@@ -479,9 +502,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();
@@ -516,16 +539,13 @@ pg_tuple_load(VALUE self, VALUE a)
 
 	RTYPEDDATA_DATA(self) = this;
 
-	if (FL_TEST(a, FL_EXIVAR)) {
-		rb_copy_generic_ivar(self, a);
-		FL_SET(self, FL_EXIVAR);
-	}
+        rb_copy_generic_ivar(self, a);
 
 	return self;
 }
 
 void
-init_pg_tuple()
+init_pg_tuple(void)
 {
 	rb_cPG_Tuple = rb_define_class_under( rb_mPG, "Tuple", rb_cObject );
 	rb_define_alloc_func( rb_cPG_Tuple, pg_tuple_s_allocate );

data/ext/pg_type_map.c

@@ -6,6 +6,40 @@
 
 #include "pg.h"
 
+void
+pg_typemap_mark( void *_this )
+{
+	t_typemap *this = (t_typemap *)_this;
+	rb_gc_mark_movable(this->default_typemap);
+}
+
+size_t
+pg_typemap_memsize( const void *_this )
+{
+	t_typemap *this = (t_typemap *)_this;
+	return sizeof(*this);
+}
+
+void
+pg_typemap_compact( void *_this )
+{
+	t_typemap *this = (t_typemap *)_this;
+	pg_gc_location(this->default_typemap);
+}
+
+const rb_data_type_t pg_typemap_type = {
+	"PG::TypeMap",
+	{
+		pg_typemap_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_typemap_memsize,
+		pg_compact_callback(pg_typemap_compact),
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE rb_cTypeMap;
 VALUE rb_mDefaultTypeMappable;
 static ID s_id_fit_to_query;
@@ -75,7 +109,7 @@ pg_typemap_s_allocate( VALUE klass )
 	VALUE self;
 	t_typemap *this;
 
-	self = Data_Make_Struct( klass, t_typemap, NULL, -1, this );
+	self = TypedData_Make_Struct( klass, t_typemap, &pg_typemap_type, this );
 	this->funcs = pg_typemap_funcs;
 
 	return self;
@@ -94,13 +128,12 @@ pg_typemap_s_allocate( VALUE klass )
 static VALUE
 pg_typemap_default_type_map_set(VALUE self, VALUE typemap)
 {
-	t_typemap *this = DATA_PTR( self );
+	t_typemap *this = RTYPEDDATA_DATA( self );
+	t_typemap *tm;
+	UNUSED(tm);
 
-	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 ) );
-	}
-	Check_Type(typemap, T_DATA);
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
 	this->default_typemap = typemap;
 
 	return typemap;
@@ -119,7 +152,7 @@ pg_typemap_default_type_map_set(VALUE self, VALUE typemap)
 static VALUE
 pg_typemap_default_type_map_get(VALUE self)
 {
-	t_typemap *this = DATA_PTR( self );
+	t_typemap *this = RTYPEDDATA_DATA( self );
 
 	return this->default_typemap;
 }
@@ -143,7 +176,7 @@ pg_typemap_with_default_type_map(VALUE self, VALUE typemap)
 }
 
 void
-init_pg_type_map()
+init_pg_type_map(void)
 {
 	s_id_fit_to_query = rb_intern("fit_to_query");
 	s_id_fit_to_result = rb_intern("fit_to_result");

data/ext/pg_type_map_all_strings.c

@@ -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,
+};
+
 VALUE rb_cTypeMapAllStrings;
 VALUE pg_typemap_all_strings;
 
@@ -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

data/ext/pg_type_map_by_class.c

@@ -10,7 +10,6 @@
 #include "pg.h"
 
 static VALUE rb_cTypeMapByClass;
-static ID s_id_ancestors;
 
 typedef struct {
 	t_typemap typemap;
@@ -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,7 +62,7 @@ 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 Symbol: Call the method with this name. */
@@ -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,32 +111,62 @@ 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 )
 {
-	rb_gc_mark(this->typemap.default_typemap);
-	rb_gc_mark(this->klass_to_coder);
-	rb_gc_mark(this->self);
-	/* Clear the cache, to be safe from changes of klass VALUE by GC.compact.
-	 * TODO: Move cache clearing to compactation callback provided by Ruby-2.7+.
-	 */
+	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 )
+{
+	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,
+};
+
 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;
@@ -153,7 +180,7 @@ pg_tmbk_s_allocate( VALUE klass )
 	this->self = 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;
 }
@@ -176,7 +203,7 @@ 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 );
 
 	if(NIL_P(coder)){
 		rb_hash_delete( this->klass_to_coder, klass );
@@ -200,7 +227,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);
 }
@@ -214,16 +241,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
 	 *