pg 1.1.3 → 1.5.4

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( t_pg_tuple *this )
+pg_tuple_gc_mark( 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 );
+	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( this->values[i] );
+		rb_gc_mark_movable( this->values[i] );
 	}
-	rb_gc_mark( pg_tuple_get_field_names(this) );
+	rb_gc_mark_movable( pg_tuple_get_field_names(this) );
 }
 
 static void
-pg_tuple_gc_free( t_pg_tuple *this )
+pg_tuple_gc_compact( void *_this )
 {
+	t_pg_tuple *this = (t_pg_tuple *)_this;
+	int i;
+
+	if( !this ) return;
+	pg_gc_location( this->result );
+	pg_gc_location( this->typemap );
+	pg_gc_location( this->field_map );
+
+	for( i = 0; i < this->num_fields; i++ ){
+		pg_gc_location( this->values[i] );
+	}
+	pg_gc_location( *pg_tuple_get_field_names_ptr(this) );
+}
+
+static void
+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
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*
@@ -132,11 +158,10 @@ pg_tuple_new(VALUE result, int row_num)
 		sizeof(*this) +
 		sizeof(*this->values) * num_fields +
 		sizeof(*this->values) * (dup_names ? 1 : 0));
-	RTYPEDDATA_DATA(self) = this;
 
-	this->result = result;
-	this->typemap = p_result->typemap;
-	this->field_map = field_map;
+	RB_OBJ_WRITE(self, &this->result, result);
+	RB_OBJ_WRITE(self, &this->typemap, p_result->typemap);
+	RB_OBJ_WRITE(self, &this->field_map, field_map);
 	this->row_num = row_num;
 	this->num_fields = num_fields;
 
@@ -148,9 +173,12 @@ pg_tuple_new(VALUE result, int row_num)
 		/* Some of the column names are duplicated -> we need the keys as Array in addition.
 		 * Store it behind the values to save the space in the common case of no dups.
 		 */
-		this->values[num_fields] = rb_obj_freeze(rb_ary_new4(num_fields, p_result->fnames));
+		VALUE keys_array = rb_obj_freeze(rb_ary_new4(num_fields, p_result->fnames));
+		RB_OBJ_WRITE(self, &this->values[num_fields], keys_array);
 	}
 
+	RTYPEDDATA_DATA(self) = this;
+
 	return self;
 }
 
@@ -166,38 +194,41 @@ pg_tuple_get_this( VALUE self )
 }
 
 static VALUE
-pg_tuple_materialize_field(t_pg_tuple *this, int col)
+pg_tuple_materialize_field(VALUE self, int col)
 {
+	t_pg_tuple *this = RTYPEDDATA_DATA( self );
 	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);
-		this->values[col] = value;
+		RB_OBJ_WRITE(self, &this->values[col], value);
 	}
 
 	return value;
 }
 
 static void
-pg_tuple_detach(t_pg_tuple *this)
+pg_tuple_detach(VALUE self)
 {
-	this->result = Qnil;
-	this->typemap = Qnil;
+	t_pg_tuple *this = RTYPEDDATA_DATA( self );
+	RB_OBJ_WRITE(self, &this->result, Qnil);
+	RB_OBJ_WRITE(self, &this->typemap, Qnil);
 	this->row_num = -1;
 }
 
 static void
-pg_tuple_materialize(t_pg_tuple *this)
+pg_tuple_materialize(VALUE self)
 {
+	t_pg_tuple *this = RTYPEDDATA_DATA( self );
 	int field_num;
 	for(field_num = 0; field_num < this->num_fields; field_num++) {
-		pg_tuple_materialize_field(this, field_num);
+		pg_tuple_materialize_field(self, field_num);
 	}
 
-	pg_tuple_detach(this);
+	pg_tuple_detach(self);
 }
 
 /*
@@ -211,7 +242,7 @@ pg_tuple_materialize(t_pg_tuple *this)
  * An integer +key+ is interpreted as column index.
  * Negative values of index count from the end of the array.
  *
- * A string +key+ is interpreted as column name.
+ * Depending on Result#field_name_type= a string or symbol +key+ is interpreted as column name.
  *
  * If the key can't be found, there are several options:
  * With no other arguments, it will raise a IndexError exception;
@@ -259,14 +290,21 @@ pg_tuple_fetch(int argc, VALUE *argv, VALUE self)
 			field_num = NUM2INT(index);
 	}
 
-	return pg_tuple_materialize_field(this, field_num);
+	return pg_tuple_materialize_field(self, field_num);
 }
 
 /*
  * call-seq:
- *    res[ name ] -> value
+ *    tup[ key ] -> value
  *
- * Returns field _name_.
+ * Returns a field value by either column index or column name.
+ *
+ * An integer +key+ is interpreted as column index.
+ * Negative values of index count from the end of the array.
+ *
+ * Depending on Result#field_name_type= a string or symbol +key+ is interpreted as column name.
+ *
+ * If the key can't be found, it returns +nil+ .
  */
 static VALUE
 pg_tuple_aref(VALUE self, VALUE key)
@@ -290,7 +328,7 @@ pg_tuple_aref(VALUE self, VALUE key)
 			field_num = NUM2INT(index);
 	}
 
-	return pg_tuple_materialize_field(this, field_num);
+	return pg_tuple_materialize_field(self, field_num);
 }
 
 static VALUE
@@ -301,10 +339,9 @@ pg_tuple_num_fields_for_enum(VALUE self, VALUE args, VALUE eobj)
 }
 
 static int
-pg_tuple_yield_key_value(VALUE key, VALUE index, VALUE _this)
+pg_tuple_yield_key_value(VALUE key, VALUE index, VALUE self)
 {
-	t_pg_tuple *this = (t_pg_tuple *)_this;
-	VALUE value = pg_tuple_materialize_field(this, NUM2INT(index));
+	VALUE value = pg_tuple_materialize_field(self, NUM2INT(index));
 	rb_yield_values(2, key, value);
 	return ST_CONTINUE;
 }
@@ -326,16 +363,16 @@ pg_tuple_each(VALUE self)
 	field_names = pg_tuple_get_field_names(this);
 
 	if( field_names == Qfalse ){
-		rb_hash_foreach(this->field_map, pg_tuple_yield_key_value, (VALUE)this);
+		rb_hash_foreach(this->field_map, pg_tuple_yield_key_value, self);
 	} else {
 		int i;
 		for( i = 0; i < this->num_fields; i++ ){
-			VALUE value = pg_tuple_materialize_field(this, i);
+			VALUE value = pg_tuple_materialize_field(self, i);
 			rb_yield_values(2, RARRAY_AREF(field_names, i), value);
 		}
 	}
 
-	pg_tuple_detach(this);
+	pg_tuple_detach(self);
 	return self;
 }
 
@@ -354,11 +391,11 @@ pg_tuple_each_value(VALUE self)
 	RETURN_SIZED_ENUMERATOR(self, 0, NULL, pg_tuple_num_fields_for_enum);
 
 	for(field_num = 0; field_num < this->num_fields; field_num++) {
-		VALUE value = pg_tuple_materialize_field(this, field_num);
+		VALUE value = pg_tuple_materialize_field(self, field_num);
 		rb_yield(value);
 	}
 
-	pg_tuple_detach(this);
+	pg_tuple_detach(self);
 	return self;
 }
 
@@ -375,7 +412,7 @@ pg_tuple_values(VALUE self)
 {
 	t_pg_tuple *this = pg_tuple_get_this(self);
 
-	pg_tuple_materialize(this);
+	pg_tuple_materialize(self);
 	return rb_ary_new4(this->num_fields, &this->values[0]);
 }
 
@@ -428,7 +465,7 @@ pg_tuple_dump(VALUE self)
 	VALUE a;
 	t_pg_tuple *this = pg_tuple_get_this(self);
 
-	pg_tuple_materialize(this);
+	pg_tuple_materialize(self);
 
 	field_names = pg_tuple_get_field_names(this);
 	if( field_names == Qfalse )
@@ -437,10 +474,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;
 }
@@ -457,7 +491,6 @@ pg_tuple_load(VALUE self, VALUE a)
 	int dup_names;
 
 	rb_check_frozen(self);
-	rb_check_trusted(self);
 
 	TypedData_Get_Struct(self, t_pg_tuple, &pg_tuple_type, this);
 	if (this)
@@ -472,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();
@@ -489,35 +522,33 @@ pg_tuple_load(VALUE self, VALUE a)
 		sizeof(*this) +
 		sizeof(*this->values) * num_fields +
 		sizeof(*this->values) * (dup_names ? 1 : 0));
-	RTYPEDDATA_DATA(self) = this;
 
-	this->result = Qnil;
-	this->typemap = Qnil;
+	RB_OBJ_WRITE(self, &this->result, Qnil);
+	RB_OBJ_WRITE(self, &this->typemap, Qnil);
 	this->row_num = -1;
 	this->num_fields = num_fields;
-	this->field_map = field_map;
+	RB_OBJ_WRITE(self, &this->field_map, field_map);
 
 	for( i = 0; i < num_fields; i++ ){
 		VALUE v = RARRAY_AREF(values, i);
 		if( v == Qundef )
 			rb_raise(rb_eTypeError, "field %d is not materialized", i);
-		this->values[i] = v;
+		RB_OBJ_WRITE(self, &this->values[i], v);
 	}
 
 	if( dup_names ){
-		this->values[num_fields] = field_names;
+		RB_OBJ_WRITE(self, &this->values[num_fields], field_names);
 	}
 
-	if (FL_TEST(a, FL_EXIVAR)) {
-		rb_copy_generic_ivar(self, a);
-		FL_SET(self, FL_EXIVAR);
-	}
+	RTYPEDDATA_DATA(self) = this;
+
+	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

@@ -1,11 +1,45 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map.c,v 2af122820861 2017/01/14 19:56:36 lars $
+ * $Id$
  *
  */
 
 #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 | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 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,14 +128,14 @@ 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);
-	this->default_typemap = typemap;
+	rb_check_frozen(self);
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
+	RB_OBJ_WRITE(self, &this->default_typemap, typemap);
 
 	return typemap;
 }
@@ -119,7 +153,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 +177,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

@@ -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 );
 }