pg 1.6.2 → 1.7.0

data/ext/pg_result.c

@@ -7,11 +7,12 @@
 #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 );
 static t_pg_result *pgresult_get_this_safe( VALUE );
+static void ensure_init_for_tuple(VALUE self);
 
 #if defined(HAVE_PQRESULTMEMORYSIZE)
 
@@ -114,7 +115,6 @@ pgresult_gc_mark( void *_this )
 
 	rb_gc_mark_movable( this->connection );
 	rb_gc_mark_movable( this->typemap );
-	rb_gc_mark_movable( this->tuple_hash );
 	rb_gc_mark_movable( this->field_map );
 
 	for( i=0; i < this->nfields; i++ ){
@@ -130,7 +130,6 @@ pgresult_gc_compact( void *_this )
 
 	pg_gc_location( this->connection );
 	pg_gc_location( this->typemap );
-	pg_gc_location( this->tuple_hash );
 	pg_gc_location( this->field_map );
 
 	for( i=0; i < this->nfields; i++ ){
@@ -181,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 */
@@ -212,7 +211,6 @@ pg_new_result2(PGresult *result, VALUE rb_pgconn)
 	this->typemap = pg_typemap_all_strings;
 	this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 	this->nfields = -1;
-	this->tuple_hash = Qnil;
 	this->field_map = Qnil;
 	this->flags = 0;
 	self = TypedData_Wrap_Struct(rb_cPGresult, &pgresult_type, this);
@@ -317,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) );
@@ -396,6 +394,7 @@ pg_result_freeze(VALUE self)
 {
 	t_pg_result *this = pgresult_get_this(self);
 
+	ensure_init_for_tuple(self);
 	RB_OBJ_WRITE(self, &this->connection, Qnil);
 	return rb_call_super(0, NULL);
 }
@@ -466,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);
@@ -477,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;
 }
@@ -513,20 +504,48 @@ static void pgresult_init_fnames(VALUE self)
  *
  * The class to represent the query result tuples (rows).
  * An instance of this class is created as the result of every query.
- * All result rows and columns are stored in a memory block attached to the PG::Result object.
- * Whenever a value is accessed it is casted to a Ruby object by the assigned #type_map .
+ * All result rows and columns are stored in an immutable memory block attached to the PG::Result object unless streaming is used.
  *
- * 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.
- *
- * Example:
+ * A PG::Result has various ways to retrieve the result data:
  *    require 'pg'
- *    conn = PG.connect(:dbname => 'test')
- *    res  = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
- *    res.getvalue(0,0) # '1'
- *    res[0]['b']       # '2'
- *    res[0]['c']       # nil
+ *    conn = PG.connect(dbname: 'test')
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.num_fields       # 3
+ *    res.num_tuples       # 1
+ *    res.fname(2)         # "c"
+ *    res.fields           # ["a", "b", "c"]
+ *    res.getvalue(0,0)    # '1'
+ *    res[0]               # {"a" => "1", "b" => "2", "c" => "3"}
+ *    res.tuple_values(0)  # ["1", "2", nil]
+ *    res.tuple(0)         # #<PG::Tuple a: "1", b: "2", c: nil>
+ *    res.values           # [["1", "2", nil]]
+ *    res.field_values(:a) # ["1"]
+ *    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= .
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.type_map = PG::TypeMapByColumn.new([PG::TextDecoder::Integer.new]*3)
+ *    res.field_name_type = :symbol
+ *    res.fname(2)         # :c
+ *    res.fields           # [:a, :b, :c]
+ *    res.getvalue(0,0)    # 1
+ *    res[0]               # {a: 1, b: 2, c: nil}
+ *    res.tuple_values(0)  # [1, 2, nil]
+ *    res.tuple(0)         # #<PG::Tuple a: 1, b: 2, c: nil>
+ *    res.values           # [[1, 2, nil]]
+ *    res.field_values(:a) # [1]
+ *    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.
  */
 
 /**************************************************************************
@@ -552,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)
@@ -564,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
@@ -578,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
@@ -705,6 +724,10 @@ pgresult_error_field(VALUE self, VALUE field)
  *    res.ntuples() -> Integer
  *
  * Returns the number of tuples in the query result.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.ntuples          # 1
+ *    res.num_tuples       # 1
  */
 static VALUE
 pgresult_ntuples(VALUE self)
@@ -723,6 +746,9 @@ pgresult_ntuples_for_enum(VALUE self, VALUE args, VALUE eobj)
  *    res.nfields() -> Integer
  *
  * Returns the number of columns in the query result.
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.nfields          # 3
+ *    res.num_fields       # 3
  */
 static VALUE
 pgresult_nfields(VALUE self)
@@ -752,6 +778,8 @@ pgresult_binary_tuples(VALUE self)
  * Returns the name of the column corresponding to _index_.
  * Depending on #field_name_type= it's a String or Symbol.
  *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.fname(2)       # "c"
  */
 static VALUE
 pgresult_fname(VALUE self, VALUE index)
@@ -1122,6 +1150,9 @@ pgresult_oid_value(VALUE self)
  *    res[ n ] -> Hash
  *
  * Returns tuple _n_ as a hash.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res[0]               # {"a" => "1", "b" => "2", "c" => "3"}
  */
 static VALUE
 pgresult_aref(VALUE self, VALUE index)
@@ -1138,16 +1169,11 @@ pgresult_aref(VALUE self, VALUE index)
 	if ( tuple_num < 0 || tuple_num >= num_tuples )
 		rb_raise( rb_eIndexError, "Index %d is out of range", tuple_num );
 
-	/* We reuse the Hash of the previous output for larger row counts.
-	 * This is somewhat faster than populating an empty Hash object. */
-	tuple = NIL_P(this->tuple_hash) ? rb_hash_new() : this->tuple_hash;
+	tuple = rb_hash_new_capa(this->nfields);
 	for ( field_num = 0; field_num < this->nfields; field_num++ ) {
 		VALUE val = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, tuple_num, field_num);
 		rb_hash_aset( tuple, this->fnames[field_num], val );
 	}
-	/* Store a copy of the filled hash for use at the next row. */
-	if( num_tuples > 10 )
-		RB_OBJ_WRITE(self, &this->tuple_hash, rb_hash_dup(tuple));
 
 	return tuple;
 }
@@ -1156,7 +1182,10 @@ pgresult_aref(VALUE self, VALUE index)
  * call-seq:
  *    res.each_row { |row| ... }
  *
- * Yields each row of the result. The row is a list of column values.
+ * Yields an Array object for each row in the result.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.each_row.first   # ["1", "2", nil]
  */
 static VALUE
 pgresult_each_row(VALUE self)
@@ -1191,6 +1220,9 @@ pgresult_each_row(VALUE self)
  *    res.values -> Array
  *
  * Returns all tuples as an array of arrays.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.values           # [["1", "2", nil]]
  */
 static VALUE
 pgresult_values(VALUE self)
@@ -1240,12 +1272,13 @@ make_column_result_array( VALUE self, int col )
 
 
 /*
- *  call-seq:
- *     res.column_values( n )   -> array
+ * call-seq:
+ *    res.column_values( n )   -> array
  *
- *  Returns an Array of the values from the nth column of each
- *  tuple in the result.
+ * Returns an Array of the values from the nth column of each tuple in the result.
  *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.column_values(1) # ["2"]
  */
 static VALUE
 pgresult_column_values(VALUE self, VALUE index)
@@ -1256,11 +1289,13 @@ pgresult_column_values(VALUE self, VALUE index)
 
 
 /*
- *  call-seq:
+ * call-seq:
  *     res.field_values( field )   -> array
  *
- *  Returns an Array of the values from the given _field_ of each tuple in the result.
+ * Returns an Array of the values from the given _field_ of each tuple in the result.
  *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.field_values(:a) # ["1"]
  */
 static VALUE
 pgresult_field_values( VALUE self, VALUE field )
@@ -1281,11 +1316,13 @@ pgresult_field_values( VALUE self, VALUE field )
 
 
 /*
- *  call-seq:
- *     res.tuple_values( n )   -> array
+ * call-seq:
+ *    res.tuple_values( n )   -> array
  *
- *  Returns an Array of the field values from the nth row of the result.
+ * Returns an Array of the field values from the nth row of the result.
  *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.tuple_values(0)  # ["1", "2", nil]
  */
 static VALUE
 pgresult_tuple_values(VALUE self, VALUE index)
@@ -1320,11 +1357,12 @@ static void ensure_init_for_tuple(VALUE self)
 
 	if( this->field_map == Qnil ){
 		int i;
-		VALUE field_map = rb_hash_new();
+		VALUE field_map;
 
 		if( this->nfields == -1 )
 			pgresult_init_fnames( self );
 
+		field_map = rb_hash_new_capa(this->nfields);
 		for( i = 0; i < this->nfields; i++ ){
 			rb_hash_aset(field_map, this->fnames[i], INT2FIX(i));
 		}
@@ -1334,11 +1372,13 @@ static void ensure_init_for_tuple(VALUE self)
 }
 
 /*
- *  call-seq:
- *     res.tuple( n )   -> PG::Tuple
+ * call-seq:
+ *    res.tuple( n )   -> PG::Tuple
  *
- *  Returns a PG::Tuple from the nth row of the result.
+ * Returns a PG::Tuple from the nth row of the result.
  *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.tuple(0)         # #<PG::Tuple a: "1", b: "2", c: nil>
  */
 static VALUE
 pgresult_tuple(VALUE self, VALUE index)
@@ -1363,7 +1403,10 @@ pgresult_tuple(VALUE self, VALUE index)
  * call-seq:
  *    res.each{ |tuple| ... }
  *
- * Invokes block for each tuple in the result set.
+ * Yields a Hash object for each row in the result.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.each.first       # {"a" => "1", "b" => "2", "c" => nil}
  */
 static VALUE
 pgresult_each(VALUE self)
@@ -1381,11 +1424,40 @@ 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
  *
  * Depending on #field_name_type= returns an array of strings or symbols representing the names of the fields in the result.
+ *
+ *    res = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
+ *    res.fields           # ["a", "b", "c"]
  */
 static VALUE
 pgresult_fields(VALUE self)
@@ -1410,6 +1482,7 @@ pgresult_fields(VALUE self)
  *
  * +typemap+ must be a kind of PG::TypeMap .
  *
+ * See also #map_types! and PG::BasicTypeMapForResults
  */
 static VALUE
 pgresult_type_map_set(VALUE self, VALUE typemap)
@@ -1433,6 +1506,7 @@ pgresult_type_map_set(VALUE self, VALUE typemap)
  *    res.type_map -> value
  *
  * Returns the PG::TypeMap that is currently set for type casts of result values to ruby objects.
+ * The default is retrieved from PG::Connection#type_map_for_results , which defaults to PG::TypeMapAllStrings .
  *
  */
 static VALUE
@@ -1525,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;
@@ -1543,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");
 
@@ -1638,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+ .
  *
@@ -1661,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);
 
@@ -1682,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;
 	}
@@ -1694,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);
@@ -1743,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,
 };
 
 /*
@@ -510,7 +510,7 @@ pg_tuple_load(VALUE self, VALUE a)
 	if (RARRAY_LENINT(field_names) != num_fields)
 		rb_raise(rb_eTypeError, "different number of fields and values");
 
-	field_map = rb_hash_new();
+	field_map = rb_hash_new_capa(num_fields);
 	for( i = 0; i < num_fields; i++ ){
 		rb_hash_aset(field_map, RARRAY_AREF(field_names, i), INT2FIX(i));
 	}

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,
 };
 
 /*