pg 1.4.6-x64-mingw-ucrt → 1.5.0-x64-mingw-ucrt

data/ext/pg_text_decoder.c

@@ -43,7 +43,6 @@
 #include <string.h>
 
 VALUE rb_mPG_TextDecoder;
-static ID s_id_decode;
 static ID s_id_Rational;
 static ID s_id_new;
 static ID s_id_utc;
@@ -171,6 +170,19 @@ pg_text_dec_numeric(t_pg_coder *conv, const char *val, int len, int tuple, int f
 	return rb_funcall(rb_cObject, s_id_BigDecimal, 1, rb_str_new(val, len));
 }
 
+/* called per autoload when TextDecoder::Numeric is used */
+static VALUE
+init_pg_text_decoder_numeric(VALUE rb_mPG_TextDecoder)
+{
+	rb_require("bigdecimal");
+	s_id_BigDecimal = rb_intern("BigDecimal");
+
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Numeric", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Numeric", pg_text_dec_numeric, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
+
+	return Qnil;
+}
+
 /*
  * Document-class: PG::TextDecoder::Float < PG::SimpleDecoder
  *
@@ -922,8 +934,9 @@ pg_text_dec_inet(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
 	return ip;
 }
 
-void
-init_pg_text_decoder(void)
+/* called per autoload when TextDecoder::Inet is used */
+static VALUE
+init_pg_text_decoder_inet(VALUE rb_mPG_TextDecoder)
 {
 	rb_require("ipaddr");
 	s_IPAddr = rb_funcall(rb_cObject, rb_intern("const_get"), 1, rb_str_new2("IPAddr"));
@@ -942,14 +955,21 @@ init_pg_text_decoder(void)
 	s_vmasks6 = rb_eval_string("a = [0]*129; a[0] = 0; a[128] = 0xffffffffffffffffffffffffffffffff; 127.downto(1){|i| a[i] = a[i+1] - (1 << (127 - i))}; a.freeze");
 	rb_global_variable(&s_vmasks6);
 
-	s_id_decode = rb_intern("decode");
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Inet", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Inet", pg_text_dec_inet, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder);
+
+	return Qnil;
+}
+
+
+void
+init_pg_text_decoder(void)
+{
 	s_id_Rational = rb_intern("Rational");
 	s_id_new = rb_intern("new");
 	s_id_utc = rb_intern("utc");
 	s_id_getlocal = rb_intern("getlocal");
 
-	rb_require("bigdecimal");
-	s_id_BigDecimal = rb_intern("BigDecimal");
 	s_nan = rb_eval_string("0.0/0.0");
 	rb_global_variable(&s_nan);
 	s_pos_inf = rb_eval_string("1.0/0.0");
@@ -959,6 +979,8 @@ init_pg_text_decoder(void)
 
 	/* This module encapsulates all decoder classes with text input format */
 	rb_mPG_TextDecoder = rb_define_module_under( rb_mPG, "TextDecoder" );
+	rb_define_private_method(rb_singleton_class(rb_mPG_TextDecoder), "init_inet", init_pg_text_decoder_inet, 0);
+	rb_define_private_method(rb_singleton_class(rb_mPG_TextDecoder), "init_numeric", init_pg_text_decoder_numeric, 0);
 
 	/* Make RDoc aware of the decoder classes... */
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Boolean", rb_cPG_SimpleDecoder ); */
@@ -967,8 +989,6 @@ init_pg_text_decoder(void)
 	pg_define_coder( "Integer", pg_text_dec_integer, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Float", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Float", pg_text_dec_float, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
-	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Numeric", rb_cPG_SimpleDecoder ); */
-	pg_define_coder( "Numeric", pg_text_dec_numeric, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "String", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Bytea", rb_cPG_SimpleDecoder ); */
@@ -977,8 +997,6 @@ init_pg_text_decoder(void)
 	pg_define_coder( "Identifier", pg_text_dec_identifier, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Timestamp", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Timestamp", pg_text_dec_timestamp, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder);
-	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Inet", rb_cPG_SimpleDecoder ); */
-	pg_define_coder( "Inet", pg_text_dec_inet, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder);
 
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Array", rb_cPG_CompositeDecoder ); */
 	pg_define_coder( "Array", pg_text_dec_array, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );

data/ext/pg_text_encoder.c

@@ -371,6 +371,21 @@ pg_text_enc_numeric(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 	}
 }
 
+/* called per autoload when TextEncoder::Numeric is used */
+static VALUE
+init_pg_text_encoder_numeric(VALUE rb_mPG_TextDecoder)
+{
+	s_str_F = rb_str_freeze(rb_str_new_cstr("F"));
+	rb_global_variable(&s_str_F);
+	rb_require("bigdecimal");
+	s_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Numeric", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Numeric", pg_text_enc_numeric, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+
+	return Qnil;
+}
+
 
 static const char hextab[] = {
 	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
@@ -383,8 +398,12 @@ static const char hextab[] = {
  *
  * The binary String is converted to hexadecimal representation for transmission
  * in text format. For query bind parameters it is recommended to use
- * PG::BinaryEncoder::Bytea instead, in order to decrease network traffic and
- * CPU usage.
+ * PG::BinaryEncoder::Bytea or the hash form <tt>{value: binary_string, format: 1}</tt> instead,
+ * in order to decrease network traffic and CPU usage.
+ * See PG::Connection#exec_params for using the hash form.
+ *
+ * This encoder is particular useful when PG::TextEncoder::CopyRow is used with the COPY command.
+ * In this case there's no way to change the format of a single column to binary, so that the data have to be converted to bytea hex representation.
  *
  */
 static int
@@ -780,14 +799,10 @@ init_pg_text_encoder(void)
 	s_id_encode = rb_intern("encode");
 	s_id_to_i = rb_intern("to_i");
 	s_id_to_s = rb_intern("to_s");
-	s_str_F = rb_str_freeze(rb_str_new_cstr("F"));
-	rb_global_variable(&s_str_F);
-	rb_require("bigdecimal");
-	s_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
-
 
 	/* This module encapsulates all encoder classes with text output format */
 	rb_mPG_TextEncoder = rb_define_module_under( rb_mPG, "TextEncoder" );
+	rb_define_private_method(rb_singleton_class(rb_mPG_TextEncoder), "init_numeric", init_pg_text_encoder_numeric, 0);
 
 	/* Make RDoc aware of the encoder classes... */
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Boolean", rb_cPG_SimpleEncoder ); */
@@ -796,8 +811,6 @@ init_pg_text_encoder(void)
 	pg_define_coder( "Integer", pg_text_enc_integer, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Float", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "Float", pg_text_enc_float, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
-	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Numeric", rb_cPG_SimpleEncoder ); */
-	pg_define_coder( "Numeric", pg_text_enc_numeric, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "String", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "String", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Bytea", rb_cPG_SimpleEncoder ); */

data/ext/pg_tuple.c

@@ -128,7 +128,7 @@ static const rb_data_type_t pg_tuple_type = {
 		pg_compact_callback(pg_tuple_gc_compact),
 	},
 	0, 0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*
@@ -159,9 +159,9 @@ pg_tuple_new(VALUE result, int row_num)
 		sizeof(*this->values) * num_fields +
 		sizeof(*this->values) * (dup_names ? 1 : 0));
 
-	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;
 
@@ -173,7 +173,8 @@ 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;
@@ -193,8 +194,9 @@ 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 ){
@@ -202,29 +204,31 @@ pg_tuple_materialize_field(t_pg_tuple *this, int col)
 
 		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);
 }
 
 /*
@@ -286,7 +290,7 @@ 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);
 }
 
 /*
@@ -324,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
@@ -335,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;
 }
@@ -360,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;
 }
 
@@ -388,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;
 }
 
@@ -409,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]);
 }
 
@@ -462,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 )
@@ -520,26 +523,26 @@ pg_tuple_load(VALUE self, VALUE a)
 		sizeof(*this->values) * num_fields +
 		sizeof(*this->values) * (dup_names ? 1 : 0));
 
-	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);
 	}
 
 	RTYPEDDATA_DATA(self) = this;
 
-        rb_copy_generic_ivar(self, a);
+	rb_copy_generic_ivar(self, a);
 
 	return self;
 }

data/ext/pg_type_map.c

@@ -37,7 +37,7 @@ const rb_data_type_t pg_typemap_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 VALUE rb_cTypeMap;
@@ -132,9 +132,10 @@ pg_typemap_default_type_map_set(VALUE self, VALUE typemap)
 	t_typemap *tm;
 	UNUSED(tm);
 
+	rb_check_frozen(self);
 	/* Check type of method param */
 	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
-	this->default_typemap = typemap;
+	RB_OBJ_WRITE(self, &this->default_typemap, typemap);
 
 	return typemap;
 }

data/ext/pg_type_map_all_strings.c

@@ -18,7 +18,7 @@ static const rb_data_type_t pg_tmas_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 VALUE rb_cTypeMapAllStrings;
@@ -125,6 +125,6 @@ init_pg_type_map_all_strings(void)
 	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

@@ -157,7 +157,7 @@ static const rb_data_type_t pg_tmbk_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -173,12 +173,12 @@ pg_tmbk_s_allocate( VALUE klass )
 	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 TypedData_Make_Struct(). */
 
@@ -205,6 +205,8 @@ pg_tmbk_aset( VALUE self, VALUE klass, VALUE coder )
 {
 	t_tmbk *this = RTYPEDDATA_DATA( self );
 
+	rb_check_frozen(self);
+
 	if(NIL_P(coder)){
 		rb_hash_delete( this->klass_to_coder, klass );
 	}else{

data/ext/pg_type_map_by_column.c

@@ -232,7 +232,7 @@ static const rb_data_type_t pg_tmbc_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -266,13 +266,14 @@ pg_tmbc_init(VALUE self, VALUE conv_ary)
 	t_tmbc *this;
 	int conv_ary_len;
 
+	rb_check_frozen(self);
 	Check_Type(conv_ary, T_ARRAY);
 	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;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	RTYPEDDATA_DATA(self) = this;
 
 	for(i=0; i<conv_ary_len; i++)
@@ -283,8 +284,13 @@ pg_tmbc_init(VALUE self, VALUE conv_ary)
 			/* no type cast */
 			this->convs[i].cconv = NULL;
 		} else {
+			t_pg_coder *p_coder;
 			/* Check argument type and store the coder pointer */
-			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, this->convs[i].cconv);
+			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
+			if( p_coder ){
+				RB_OBJ_WRITTEN(self, Qnil, p_coder->coder_obj);
+			}
+			this->convs[i].cconv = p_coder;
 		}
 	}
 

data/ext/pg_type_map_by_oid.c

@@ -194,7 +194,7 @@ static const rb_data_type_t pg_tmbo_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -212,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;
@@ -242,6 +242,7 @@ pg_tmbo_add_coder( VALUE self, VALUE coder )
 	t_pg_coder *p_coder;
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
+	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 )
@@ -276,6 +277,7 @@ pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
 	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);
 
@@ -318,6 +320,7 @@ static VALUE
 pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
 {
 	t_tmbo *this = RTYPEDDATA_DATA( self );
+	rb_check_frozen(self);
 	this->max_rows_for_online_lookup = NUM2INT(value);
 	return value;
 }
@@ -338,7 +341,7 @@ 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

data/ext/pg_type_map_in_ruby.c

@@ -44,7 +44,7 @@ static const rb_data_type_t pg_tmir_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*
@@ -210,6 +210,9 @@ pg_tmir_typecast_query_param( VALUE self, VALUE param_value, VALUE field )
  * This method is called, when a type map is used for decoding copy data,
  * before the value is casted.
  *
+ * Should return the expected number of columns or 0 if the number of columns is unknown.
+ * This number is only used for memory pre-allocation.
+ *
  */
 static VALUE pg_tmir_fit_to_copy_get_dummy( VALUE self ){}
 #endif
@@ -291,7 +294,7 @@ pg_tmir_s_allocate( VALUE klass )
 	this->typemap.funcs.typecast_result_value = pg_tmir_result_value;
 	this->typemap.funcs.typecast_query_param = pg_tmir_query_param;
 	this->typemap.funcs.typecast_copy_get = pg_tmir_copy_get;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	this->self = self;
 
 	return self;

data/lib/pg/basic_type_map_based_on_result.rb

@@ -32,7 +32,27 @@ require 'pg' unless defined?( PG )
 #     conn.put_copy_data ['a', 123, [5,4,3]]
 #   end
 # This inserts a single row into copytable with type casts from ruby to
-# database types.
+# database types using text format.
+#
+# Very similar with binary format:
+#
+#   conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, blob bytea, created_at timestamp)" )
+#   # Retrieve table OIDs per empty result set in binary format.
+#   res = conn.exec_params( "SELECT * FROM copytable LIMIT 0", [], 1 )
+#   # Build a type map for common ruby to database type encoders.
+#   btm = PG::BasicTypeMapBasedOnResult.new(conn)
+#   # Build a PG::TypeMapByColumn with encoders suitable for copytable.
+#   tm = btm.build_column_map( res )
+#   row_encoder = PG::BinaryEncoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable FROM STDIN WITH (FORMAT binary)", row_encoder ) do |res|
+#     conn.put_copy_data ['a', 123, "\xff\x00".b, Time.now]
+#   end
+#
+# This inserts a single row into copytable with type casts from ruby to
+# database types using binary copy and value format.
+# Binary COPY is faster than text format but less portable and less readable and pg offers fewer en-/decoders of database types.
+#
 class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
 	include PG::BasicTypeRegistry::Checker
 

data/lib/pg/basic_type_map_for_queries.rb

@@ -47,16 +47,20 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 	# Options:
 	# * +registry+: Custom type registry, nil for default global registry
 	# * +if_undefined+: Optional +Proc+ object which is called, if no type for an parameter class is not defined in the registry.
+	#   The +Proc+ object is called with the name and format of the missing type.
+	#   Its return value is not used.
 	def initialize(connection_or_coder_maps, registry: nil, if_undefined: nil)
 		@coder_maps = build_coder_maps(connection_or_coder_maps, registry: registry)
 		@array_encoders_by_klass = array_encoders_by_klass
 		@encode_array_as = :array
-		@if_undefined = if_undefined || proc { |oid_name, format|
-			raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
-		}
+		@if_undefined = if_undefined || method(:raise_undefined_type).to_proc
 		init_encoders
 	end
 
+	private def raise_undefined_type(oid_name, format)
+		raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
+	end
+
 	# Change the mechanism that is used to encode ruby array values
 	#
 	# Possible values:
@@ -162,7 +166,7 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 				@textarray_encoder
 	end
 
-	DEFAULT_TYPE_MAP = {
+	DEFAULT_TYPE_MAP = PG.make_shareable({
 		TrueClass => [1, 'bool', 'bool'],
 		FalseClass => [1, 'bool', 'bool'],
 		# We use text format and no type OID for numbers, because setting the OID can lead
@@ -177,9 +181,10 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		Hash => [0, 'json'],
 		Array => :get_array_type,
 		BinaryData => [1, 'bytea'],
-	}
+	})
+	private_constant :DEFAULT_TYPE_MAP
 
-	DEFAULT_ARRAY_TYPE_MAP = {
+	DEFAULT_ARRAY_TYPE_MAP = PG.make_shareable({
 		TrueClass => [0, '_bool'],
 		FalseClass => [0, '_bool'],
 		Integer => [0, '_int8'],
@@ -188,6 +193,6 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		BigDecimal => [0, '_numeric'],
 		Time => [0, '_timestamptz'],
 		IPAddr => [0, '_inet'],
-	}
-
+	})
+	private_constant :DEFAULT_ARRAY_TYPE_MAP
 end