pg 1.6.3 → 1.7.0

data/ext/pg_copy_coder.c

@@ -55,7 +55,7 @@ static const rb_data_type_t pg_copycoder_type = {
 	},
 	&pg_coder_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -219,20 +219,21 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 {
 	t_pg_copycoder *this = (t_pg_copycoder *)conv;
 	t_pg_coder_enc_func enc_func;
-	static t_pg_coder *p_elem_coder;
+	t_pg_coder *p_elem_coder;
 	int i;
+	VALUE rb_typemap = this->typemap;
 	t_typemap *p_typemap;
 	char *current_out;
 	char *end_capa_ptr;
 
-	p_typemap = RTYPEDDATA_DATA( this->typemap );
-	p_typemap->funcs.fit_to_query( this->typemap, value );
+	p_typemap = RTYPEDDATA_DATA( rb_typemap );
+	p_typemap->funcs.fit_to_query( rb_typemap, value );
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
 	PG_RB_STR_NEW( *intermediate, current_out, end_capa_ptr );
 	PG_ENCODING_SET_NOCHECK(*intermediate, enc_idx);
 
-	for( i=0; i<RARRAY_LEN(value); i++){
+	for( i=0; i<RARRAY_LENINT(value); i++){
 		char *ptr1;
 		char *ptr2;
 		int strlen;
@@ -265,7 +266,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 					strlen = RSTRING_LENINT(subint);
 
 					/* size of string assuming the worst case, that every character must be escaped. */
-					PG_RB_STR_ENSURE_CAPA( *intermediate, strlen * 2, current_out, end_capa_ptr );
+					PG_RB_STR_ENSURE_CAPA( *intermediate, (size_t)strlen * 2, current_out, end_capa_ptr );
 
 					/* Copy string from subint with backslash escaping */
 					for(ptr1 = RSTRING_PTR(subint); ptr1 < RSTRING_PTR(subint) + strlen; ptr1++) {
@@ -278,7 +279,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 				} else {
 					/* 2nd pass for writing the data to prepared buffer */
 					/* size of string assuming the worst case, that every character must be escaped. */
-					PG_RB_STR_ENSURE_CAPA( *intermediate, strlen * 2, current_out, end_capa_ptr );
+					PG_RB_STR_ENSURE_CAPA( *intermediate, (size_t)strlen * 2, current_out, end_capa_ptr );
 
 					/* Place the unescaped string at current output position. */
 					strlen = enc_func(p_elem_coder, entry, current_out, &subint, enc_idx);
@@ -314,6 +315,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 
 	rb_str_set_len( *intermediate, current_out - RSTRING_PTR(*intermediate) );
 
+	RB_GC_GUARD(rb_typemap);
 	return -1;
 }
 
@@ -366,12 +368,17 @@ pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediat
 {
 	t_pg_copycoder *this = (t_pg_copycoder *)conv;
 	int i;
+	VALUE rb_typemap = this->typemap;
 	t_typemap *p_typemap;
 	char *current_out;
 	char *end_capa_ptr;
 
-	p_typemap = RTYPEDDATA_DATA( this->typemap );
-	p_typemap->funcs.fit_to_query( this->typemap, value );
+	if( RARRAY_LEN(value) >= 32768 ){
+		rb_raise( rb_eArgError, "too many columns in array for PG::BinaryEncoder::CopyRow: %ld", RARRAY_LEN(value) );
+	}
+
+	p_typemap = RTYPEDDATA_DATA( rb_typemap );
+	p_typemap->funcs.fit_to_query( rb_typemap, value );
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
 	PG_RB_STR_NEW( *intermediate, current_out, end_capa_ptr );
@@ -382,12 +389,12 @@ pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediat
 	write_nbo16(RARRAY_LEN(value), current_out);
 	current_out += 2;
 
-	for( i=0; i<RARRAY_LEN(value); i++){
+	for( i=0; i<RARRAY_LENINT(value); i++){
 		int strlen;
 		VALUE subint;
 		VALUE entry;
 		t_pg_coder_enc_func enc_func;
-		static t_pg_coder *p_elem_coder;
+		t_pg_coder *p_elem_coder;
 
 		entry = rb_ary_entry(value, i);
 
@@ -409,7 +416,7 @@ pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediat
 					/* we can directly use String value in subint */
 					strlen = RSTRING_LENINT(subint);
 
-					PG_RB_STR_ENSURE_CAPA( *intermediate, 4 + strlen, current_out, end_capa_ptr );
+					PG_RB_STR_ENSURE_CAPA( *intermediate, (size_t)4 + strlen, current_out, end_capa_ptr );
 					/* 4 bytes length */
 					write_nbo32(strlen, current_out);
 					current_out += 4;
@@ -418,7 +425,7 @@ pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediat
 					current_out += strlen;
 				} else {
 					/* 2nd pass for writing the data to prepared buffer */
-					PG_RB_STR_ENSURE_CAPA( *intermediate, 4 + strlen, current_out, end_capa_ptr );
+					PG_RB_STR_ENSURE_CAPA( *intermediate, (size_t)4 + strlen, current_out, end_capa_ptr );
 					/* 4 bytes length */
 					write_nbo32(strlen, current_out);
 					current_out += 4;
@@ -432,6 +439,7 @@ pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediat
 
 	rb_str_set_len( *intermediate, current_out - RSTRING_PTR(*intermediate) );
 
+	RB_GC_GUARD(rb_typemap);
 	return -1;
 }
 
@@ -530,10 +538,11 @@ pg_text_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tup
 	const char *cur_ptr;
 	const char *line_end_ptr;
 	char *end_capa_ptr;
+	VALUE rb_typemap = this->typemap;
 	t_typemap *p_typemap;
 
-	p_typemap = RTYPEDDATA_DATA( this->typemap );
-	expected_fields = p_typemap->funcs.fit_to_copy_get( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( rb_typemap );
+	expected_fields = p_typemap->funcs.fit_to_copy_get( rb_typemap );
 
 	/* The received input string will probably have this->nfields fields. */
 	array = rb_ary_new2(expected_fields);
@@ -553,7 +562,7 @@ pg_text_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tup
 		int found_delim = 0;
 		const char *start_ptr;
 		const char *end_ptr;
-		long input_len;
+		size_t input_len;
 
 		/* Remember start of field on input side */
 		start_ptr = cur_ptr;
@@ -688,7 +697,7 @@ pg_text_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tup
 
 		/* Check whether raw input matched null marker */
 		input_len = end_ptr - start_ptr;
-		if (input_len == RSTRING_LEN(this->null_string) &&
+		if (input_len == (size_t)RSTRING_LEN(this->null_string) &&
 					strncmp(start_ptr, RSTRING_PTR(this->null_string), input_len) == 0) {
 			rb_ary_push(array, Qnil);
 		} else {
@@ -714,11 +723,13 @@ pg_text_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tup
 			break;
 	}
 
+	RB_GC_GUARD(rb_typemap);
+
 	return array;
 }
 
 
-static const char BinarySignature[11] = "PGCOPY\n\377\r\n\0";
+static const char BinarySignature[11] = {'P','G','C','O','P','Y','\n','\377','\r','\n','\0'};
 
 /*
  * Document-class: PG::BinaryDecoder::CopyRow < PG::CopyDecoder
@@ -786,10 +797,11 @@ pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tupl
 	const char *cur_ptr;
 	const char *line_end_ptr;
 	char *end_capa_ptr;
+	VALUE rb_typemap = this->typemap;
 	t_typemap *p_typemap;
 
-	p_typemap = RTYPEDDATA_DATA( this->typemap );
-	expected_fields = p_typemap->funcs.fit_to_copy_get( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( rb_typemap );
+	expected_fields = p_typemap->funcs.fit_to_copy_get( rb_typemap );
 
 	/* Allocate a new string with embedded capacity and realloc later with
 	 * exponential growing size when needed. */
@@ -830,7 +842,7 @@ pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tupl
 		array = rb_ary_new2(expected_fields);
 
 		for( fieldno = 0; fieldno < nfields; fieldno++){
-			long input_len;
+			int input_len;
 
 			/* read field size */
 			if (line_end_ptr - cur_ptr < 4 ) goto length_error;
@@ -871,6 +883,7 @@ pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tupl
 	if (cur_ptr < line_end_ptr)
 		rb_raise( rb_eArgError, "trailing data after row data at position: %ld", (long)(cur_ptr - input_line) + 1 );
 
+	RB_GC_GUARD(rb_typemap);
 	return array;
 
 length_error:

data/ext/pg_record_coder.c

@@ -47,7 +47,7 @@ static const rb_data_type_t pg_recordcoder_type = {
 	},
 	&pg_coder_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -179,14 +179,15 @@ pg_text_enc_record(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 {
 	t_pg_recordcoder *this = (t_pg_recordcoder *)conv;
 	t_pg_coder_enc_func enc_func;
-	static t_pg_coder *p_elem_coder;
+	t_pg_coder *p_elem_coder;
 	int i;
+	VALUE rb_typemap = this->typemap;
 	t_typemap *p_typemap;
 	char *current_out;
 	char *end_capa_ptr;
 
-	p_typemap = RTYPEDDATA_DATA( this->typemap );
-	p_typemap->funcs.fit_to_query( this->typemap, value );
+	p_typemap = RTYPEDDATA_DATA( rb_typemap );
+	p_typemap->funcs.fit_to_query( rb_typemap, value );
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
 	PG_RB_STR_NEW( *intermediate, current_out, end_capa_ptr );
@@ -277,6 +278,7 @@ pg_text_enc_record(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 
 	rb_str_set_len( *intermediate, current_out - RSTRING_PTR(*intermediate) );
 
+	RB_GC_GUARD(rb_typemap);
 	return -1;
 }
 
@@ -387,10 +389,11 @@ pg_text_dec_record(t_pg_coder *conv, char *input_line, int len, int _tuple, int
 	char *output_ptr;
 	char *cur_ptr;
 	char *end_capa_ptr;
+	VALUE rb_typemap = this->typemap;
 	t_typemap *p_typemap;
 
-	p_typemap = RTYPEDDATA_DATA( this->typemap );
-	expected_fields = p_typemap->funcs.fit_to_copy_get( this->typemap );
+	p_typemap = RTYPEDDATA_DATA( rb_typemap );
+	expected_fields = p_typemap->funcs.fit_to_copy_get( rb_typemap );
 
 	/* The received input string will probably have this->nfields fields. */
 	array = rb_ary_new2(expected_fields);
@@ -490,6 +493,7 @@ pg_text_dec_record(t_pg_coder *conv, char *input_line, int len, int _tuple, int
 	if (*cur_ptr)
 		rb_raise( rb_eArgError, "malformed record literal: \"%s\" - Junk after right parenthesis.", input_line );
 
+	RB_GC_GUARD(rb_typemap);
 	return array;
 }
 

data/ext/pg_result.c

@@ -7,7 +7,7 @@
 #include "pg.h"
 
 VALUE rb_cPGresult;
-static VALUE sym_symbol, sym_string, sym_static_symbol;
+static VALUE sym_symbol, sym_string;
 
 static VALUE pgresult_type_map_set( VALUE, VALUE );
 static t_pg_result *pgresult_get_this( VALUE );
@@ -180,7 +180,7 @@ static const rb_data_type_t pgresult_type = {
 		pgresult_gc_compact,
 	},
 	0, 0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /* Needed by sequel_pg gem, do not delete */
@@ -315,17 +315,17 @@ pg_result_check( VALUE self )
 		case PGRES_SINGLE_TUPLE:
 		case PGRES_EMPTY_QUERY:
 		case PGRES_COMMAND_OK:
-#ifdef HAVE_PQENTERPIPELINEMODE
+#ifdef LIBPQ_HAS_PIPELINING
 		case PGRES_PIPELINE_SYNC:
 #endif
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 		case PGRES_TUPLES_CHUNK:
 #endif
 			return self;
 		case PGRES_BAD_RESPONSE:
 		case PGRES_FATAL_ERROR:
 		case PGRES_NONFATAL_ERROR:
-#ifdef HAVE_PQENTERPIPELINEMODE
+#ifdef LIBPQ_HAS_PIPELINING
 		case PGRES_PIPELINE_ABORTED:
 #endif
 			error = rb_str_new2( PQresultErrorMessage(this->pgresult) );
@@ -465,9 +465,6 @@ pgresult_get(VALUE self)
 static VALUE pg_cstr_to_sym(char *cstr, unsigned int flags, int enc_idx)
 {
 	VALUE fname;
-#ifdef TRUFFLERUBY
-	if( flags & (PG_RESULT_FIELD_NAMES_SYMBOL | PG_RESULT_FIELD_NAMES_STATIC_SYMBOL) ){
-#else
 	if( flags & PG_RESULT_FIELD_NAMES_SYMBOL ){
 		rb_encoding *enc = rb_enc_from_index(enc_idx);
 		fname = rb_check_symbol_cstr(cstr, strlen(cstr), enc);
@@ -476,14 +473,9 @@ static VALUE pg_cstr_to_sym(char *cstr, unsigned int flags, int enc_idx)
 			PG_ENCODING_SET_NOCHECK(fname, enc_idx);
 			fname = rb_str_intern(fname);
 		}
-	} else if( flags & PG_RESULT_FIELD_NAMES_STATIC_SYMBOL ){
-#endif
-		rb_encoding *enc = rb_enc_from_index(enc_idx);
-		fname = ID2SYM(rb_intern3(cstr, strlen(cstr), enc));
 	} else {
-		fname = rb_str_new2(cstr);
-		PG_ENCODING_SET_NOCHECK(fname, enc_idx);
-		fname = rb_obj_freeze(fname);
+		rb_encoding *enc = rb_enc_from_index(enc_idx);
+		fname = rb_enc_interned_str(cstr, strlen(cstr), enc);
 	}
 	return fname;
 }
@@ -531,6 +523,7 @@ static void pgresult_init_fnames(VALUE self)
  *    res.column_values(1) # ["2"]
  *    res.each.first       # {"a" => "1", "b" => "2", "c" => nil}
  *    res.each_row.first   # ["1", "2", nil]
+ *    res.each_tuple.first # #<PG::Tuple a: "1", b: "2", c: nil>
  *
  * Whenever a value is accessed it is casted to a Ruby object by the assigned #type_map which is PG::TypeMapAllStrings by default.
  * Similarly field names can be retrieved either as strings (default) or as symbols which can be switched per #field_name_type= .
@@ -549,6 +542,7 @@ static void pgresult_init_fnames(VALUE self)
  *    res.column_values(1) # [2]
  *    res.each.first       # {a: 1, b: 2, c: nil}
  *    res.each_row.first   # [1, 2, nil]
+ *    res.each_tuple.first # #<PG::Tuple a: 1, b: 2, c: nil>
  *
  * Since pg-1.1 the amount of memory in use by a PG::Result object is estimated and passed to ruby's garbage collector.
  * You can invoke the #clear method to force deallocation of memory of the instance when finished with the result for better memory performance.
@@ -577,7 +571,7 @@ static void pgresult_init_fnames(VALUE self)
  * * +PGRES_PIPELINE_SYNC+
  * * +PGRES_PIPELINE_ABORTED+
  *
- * Use <tt>res.res_status</tt> to retrieve the string representation.
+ * Use #res_status or Result.res_status to retrieve the string representation.
  */
 static VALUE
 pgresult_result_status(VALUE self)
@@ -589,7 +583,7 @@ pgresult_result_status(VALUE self)
  * call-seq:
  *    PG::Result.res_status( status ) -> String
  *
- * Returns the string representation of +status+.
+ * Returns the string representation of #result_status.
  *
 */
 static VALUE
@@ -603,7 +597,7 @@ pgresult_s_res_status(VALUE self, VALUE status)
  *    res.res_status -> String
  *    res.res_status( status ) -> String
  *
- * Returns the string representation of the status of the result or of the provided +status+.
+ * Returns the string representation of the status of the result or of the provided #result_status.
  *
  */
 static VALUE
@@ -1430,6 +1424,32 @@ pgresult_each(VALUE self)
 	return self;
 }
 
+/*
+ * call-seq:
+ *    res.each_tuple{ |tuple| ... }
+ *
+ * Yields a PG::Tuple object for each row in the result.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.each_tuple.first  # #<PG::Tuple a: "1", b: "2", c: nil>
+ */
+static VALUE
+pgresult_each_tuple(VALUE self)
+{
+	PGresult *result;
+	int tuple_num;
+
+	RETURN_SIZED_ENUMERATOR(self, 0, NULL, pgresult_ntuples_for_enum);
+
+	result = pgresult_get(self);
+
+	for(tuple_num = 0; tuple_num < PQntuples(result); tuple_num++) {
+		VALUE tuple = pgresult_tuple(self, INT2FIX(tuple_num));
+		rb_yield( tuple );
+	}
+	return self;
+}
+
 /*
  * call-seq:
  *    res.fields() -> Array
@@ -1579,7 +1599,7 @@ pgresult_stream_any(VALUE self, int (*yielder)(VALUE, int, int, void*), void* da
 					return self;
 				rb_raise( rb_eInvalidResultStatus, "PG::Result is not in single row mode");
 			case PGRES_SINGLE_TUPLE:
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 			case PGRES_TUPLES_CHUNK:
 #endif
 				break;
@@ -1597,12 +1617,12 @@ pgresult_stream_any(VALUE self, int (*yielder)(VALUE, int, int, void*), void* da
 			pgresult_clear( this );
 		}
 
-		if( gvl_PQisBusy(pgconn) ){
+		if( PQisBusy(pgconn) ){
 			/* wait for input (without blocking) before reading each result */
 			pgconn_block( 0, NULL, this->connection );
 		}
 
-		pgresult = gvl_PQgetResult(pgconn);
+		pgresult = PQgetResult(pgconn);
 		if( pgresult == NULL )
 			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another query");
 
@@ -1692,7 +1712,6 @@ pgresult_stream_each_tuple(VALUE self)
  * It can be set to one of:
  * * +:string+ to use String based field names
  * * +:symbol+ to use Symbol based field names
- * * +:static_symbol+ to use pinned Symbol (can not be garbage collected) - Don't use this, it will probably be removed in future.
  *
  * The default is retrieved from PG::Connection#field_name_type , which defaults to +:string+ .
  *
@@ -1715,7 +1734,6 @@ pgresult_field_name_type_set(VALUE self, VALUE sym)
 
 	this->flags &= ~PG_RESULT_FIELD_NAMES_MASK;
 	if( sym == sym_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_SYMBOL;
-	else if ( sym == sym_static_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_STATIC_SYMBOL;
 	else if ( sym == sym_string );
 	else rb_raise(rb_eArgError, "invalid argument %+"PRIsVALUE, sym);
 
@@ -1736,8 +1754,6 @@ pgresult_field_name_type_get(VALUE self)
 	t_pg_result *this = pgresult_get_this(self);
 	if( this->flags & PG_RESULT_FIELD_NAMES_SYMBOL ){
 		return sym_symbol;
-	} else if( this->flags & PG_RESULT_FIELD_NAMES_STATIC_SYMBOL ){
-		return sym_static_symbol;
 	} else {
 		return sym_string;
 	}
@@ -1748,7 +1764,6 @@ init_pg_result(void)
 {
 	sym_string = ID2SYM(rb_intern("string"));
 	sym_symbol = ID2SYM(rb_intern("symbol"));
-	sym_static_symbol = ID2SYM(rb_intern("static_symbol"));
 
 	rb_cPGresult = rb_define_class_under( rb_mPG, "Result", rb_cObject );
 	rb_undef_alloc_func(rb_cPGresult);
@@ -1797,6 +1812,7 @@ init_pg_result(void)
 	rb_define_method(rb_cPGresult, "each", pgresult_each, 0);
 	rb_define_method(rb_cPGresult, "fields", pgresult_fields, 0);
 	rb_define_method(rb_cPGresult, "each_row", pgresult_each_row, 0);
+	rb_define_method(rb_cPGresult, "each_tuple", pgresult_each_tuple, 0);
 	rb_define_method(rb_cPGresult, "values", pgresult_values, 0);
 	rb_define_method(rb_cPGresult, "column_values", pgresult_column_values, 1);
 	rb_define_method(rb_cPGresult, "field_values", pgresult_field_values, 1);

data/ext/pg_text_decoder.c

@@ -942,8 +942,8 @@ static VALUE
 init_pg_text_decoder_inet(VALUE rb_mPG_TextDecoder)
 {
 	rb_require("ipaddr");
+	rb_gc_register_address(&s_IPAddr);
 	s_IPAddr = rb_funcall(rb_cObject, rb_intern("const_get"), 1, rb_str_new2("IPAddr"));
-	rb_global_variable(&s_IPAddr);
 	s_ivar_family = rb_intern("@family");
 	s_ivar_addr = rb_intern("@addr");
 	s_ivar_mask_addr = rb_intern("@mask_addr");
@@ -953,10 +953,10 @@ init_pg_text_decoder_inet(VALUE rb_mPG_TextDecoder)
 
 	use_ipaddr_alloc = RTEST(rb_eval_string("IPAddr.new.instance_variables.sort == [:@addr, :@family, :@mask_addr]"));
 
+	rb_gc_register_address(&s_vmasks4);
+	rb_gc_register_address(&s_vmasks6);
 	s_vmasks4 = rb_eval_string("a = [0]*33; a[0] = 0; a[32] = 0xffffffff; 31.downto(1){|i| a[i] = a[i+1] - (1 << (31 - i))}; a.freeze");
-	rb_global_variable(&s_vmasks4);
 	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);
 
 	/* 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);
@@ -973,12 +973,12 @@ init_pg_text_decoder(void)
 	s_id_utc = rb_intern("utc");
 	s_id_getlocal = rb_intern("getlocal");
 
+	rb_gc_register_address(&s_nan);
+	rb_gc_register_address(&s_pos_inf);
+	rb_gc_register_address(&s_neg_inf);
 	s_nan = rb_eval_string("0.0/0.0");
-	rb_global_variable(&s_nan);
 	s_pos_inf = rb_eval_string("1.0/0.0");
-	rb_global_variable(&s_pos_inf);
 	s_neg_inf = rb_eval_string("-1.0/0.0");
-	rb_global_variable(&s_neg_inf);
 
 	/* This module encapsulates all decoder classes with text input format */
 	rb_mPG_TextDecoder = rb_define_module_under( rb_mPG, "TextDecoder" );

data/ext/pg_text_encoder.c

@@ -381,8 +381,8 @@ pg_text_enc_numeric(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 static VALUE
 init_pg_text_encoder_numeric(VALUE rb_mPG_TextDecoder)
 {
+	rb_gc_register_address(&s_str_F);
 	s_str_F = rb_str_freeze(rb_str_new_cstr("F"));
-	rb_global_variable(&s_str_F);
 	rb_funcall(rb_mPG, rb_intern("require_bigdecimal_without_warning"), 0);
 	s_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 
@@ -430,9 +430,14 @@ pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 		}
 		return (int)(optr - out);
 	}else{
+		long size;
 		*intermediate = rb_obj_as_string(value);
+		size = RSTRING_LEN(*intermediate);
+
 		/* The output starts with "\x" and each character is converted to hex. */
-		return 2 + RSTRING_LENINT(*intermediate) * 2;
+		if( size > INT_MAX / 2 - 2 )
+			rb_raise( rb_eArgError, "too large input string for PG::TextEncoder::Bytea: %ld", size );
+		return (int)(2 + size * 2);
 	}
 }
 

data/ext/pg_tuple.c

@@ -128,7 +128,7 @@ static const rb_data_type_t pg_tuple_type = {
 		pg_tuple_gc_compact,
 	},
 	0, 0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*

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_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 VALUE rb_cTypeMap;
@@ -115,6 +115,45 @@ pg_typemap_s_allocate( VALUE klass )
 	return self;
 }
 
+/*
+ * call-seq:
+ *    res.query_param_encoders(params)
+ *
+ * Retrieve the encoders that are used to encode the given values to be submitted to the database server.
+ * The selection of the encoders is defined in the derived type map class.
+ *
+ * +params+ must be an Array of values to be encoded.
+ * It's like +params+ given to exec_params .
+ *
+ * Returns an Array with the same length as +params+.
+ *
+ */
+static VALUE
+pg_typemap_query_param_encoders( VALUE self, VALUE params )
+{
+	t_typemap *this = RTYPEDDATA_DATA( self );
+	int nParams;
+	int i=0;
+	VALUE res;
+
+	Check_Type(params, T_ARRAY);
+
+	this->funcs.fit_to_query( self, params );
+
+	nParams = RARRAY_LENINT(params);
+	res = rb_ary_new2(nParams);
+
+	for ( i = 0; i < nParams; i++ ) {
+		t_pg_coder *conv;
+		VALUE param_value = rb_ary_entry(params, i);
+
+		/* Let the given typemap select a coder for this param */
+		conv = this->funcs.typecast_query_param(this, param_value, i);
+		rb_ary_push(res, conv ? conv->coder_obj : Qnil);
+	}
+	return res;
+}
+
 /*
  * call-seq:
  *    res.default_type_map = typemap
@@ -194,6 +233,7 @@ init_pg_type_map(void)
 	 */
 	rb_cTypeMap = rb_define_class_under( rb_mPG, "TypeMap", rb_cObject );
 	rb_define_alloc_func( rb_cTypeMap, pg_typemap_s_allocate );
+	rb_define_method( rb_cTypeMap, "query_param_encoders", pg_typemap_query_param_encoders, 1 );
 
 	rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable");
 	rb_define_method( rb_mDefaultTypeMappable, "default_type_map=", pg_typemap_default_type_map_set, 1 );

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_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | 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_obj_freeze( rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 ));
 	rb_gc_register_address( &pg_typemap_all_strings );
+	pg_typemap_all_strings = rb_obj_freeze( rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 ));
 }

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_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE

data/ext/pg_type_map_by_column.c

@@ -55,7 +55,7 @@ pg_tmbc_fit_to_query( VALUE self, VALUE params )
 	t_typemap *default_tm;
 
 	Check_Type(params, T_ARRAY);
-	nfields = (int)RARRAY_LEN( params );
+	nfields = RARRAY_LENINT( 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 );
@@ -233,7 +233,7 @@ static const rb_data_type_t pg_tmbc_type = {
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE

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_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 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_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*

data/lib/pg/basic_type_map_based_on_result.rb

@@ -64,4 +64,9 @@ class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
 			add_coder(coder)
 		end
 	end
+
+	# Returns the PG::BasicTypeRegistry::CoderMapsBundle used to translate result OIDs to encoders.
+	def coder_maps_bundle
+		@coder_maps
+	end
 end