pg 1.5.9 → 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++ ){
@@ -147,9 +146,7 @@ pgresult_clear( void *_this )
 	t_pg_result *this = (t_pg_result *)_this;
 	if( this->pgresult && !this->autoclear ){
 		PQclear(this->pgresult);
-#ifdef HAVE_RB_GC_ADJUST_MEMORY_USAGE
 		rb_gc_adjust_memory_usage(-this->result_size);
-#endif
 	}
 	this->result_size = 0;
 	this->nfields = -1;
@@ -180,10 +177,10 @@ static const rb_data_type_t pgresult_type = {
 		pgresult_gc_mark,
 		pgresult_gc_free,
 		pgresult_memsize,
-		pg_compact_callback(pgresult_gc_compact),
+		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 */
@@ -214,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);
@@ -253,9 +249,7 @@ pg_new_result(PGresult *result, VALUE rb_pgconn)
 	 */
 	this->result_size = pgresult_approx_size(result);
 
-#ifdef HAVE_RB_GC_ADJUST_MEMORY_USAGE
 	rb_gc_adjust_memory_usage(this->result_size);
-#endif
 
 	return self;
 }
@@ -321,14 +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 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) );
@@ -397,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);
 }
@@ -467,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);
@@ -478,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;
 }
@@ -514,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 .
- *
- * 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.
+ * All result rows and columns are stored in an immutable memory block attached to the PG::Result object unless streaming is used.
  *
- * 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.
  */
 
 /**************************************************************************
@@ -549,10 +567,11 @@ static void pgresult_init_fnames(VALUE self)
  * * +PGRES_FATAL_ERROR+
  * * +PGRES_COPY_BOTH+
  * * +PGRES_SINGLE_TUPLE+
+ * * +PGRES_TUPLES_CHUNK+
  * * +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
@@ -613,14 +632,12 @@ pgresult_error_message(VALUE self)
 	return ret;
 }
 
-#ifdef HAVE_PQRESULTVERBOSEERRORMESSAGE
 /*
  * call-seq:
  *    res.verbose_error_message( verbosity, show_context ) -> String
  *
- * Returns a reformatted version of the error message associated with a PGresult object.
+ * Returns a reformatted version of the error message associated with the PG::Result object.
  *
- * Available since PostgreSQL-9.6
  */
 static VALUE
 pgresult_verbose_error_message(VALUE self, VALUE verbosity, VALUE show_context)
@@ -639,7 +656,6 @@ pgresult_verbose_error_message(VALUE self, VALUE verbosity, VALUE show_context)
 
 	return ret;
 }
-#endif
 
 /*
  * call-seq:
@@ -708,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)
@@ -726,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)
@@ -737,9 +760,9 @@ pgresult_nfields(VALUE self)
  * call-seq:
  *    res.binary_tuples() -> Integer
  *
- * Returns 1 if the PGresult contains binary data and 0 if it contains text data.
+ * Returns 1 if the PG::Result contains binary data and 0 if it contains text data.
  *
- * This function is deprecated (except for its use in connection with COPY), because it is possible for a single PGresult to contain text data in some columns and binary data in others.
+ * This function is deprecated (except for its use in connection with COPY), because it is possible for a single PG::Result to contain text data in some columns and binary data in others.
  * Result#fformat is preferred. binary_tuples returns 1 only if all columns of the result are binary (format 1).
  */
 static VALUE
@@ -755,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)
@@ -1125,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)
@@ -1141,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;
 }
@@ -1159,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)
@@ -1194,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)
@@ -1243,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)
@@ -1259,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 )
@@ -1284,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)
@@ -1323,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));
 		}
@@ -1337,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)
@@ -1366,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)
@@ -1384,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)
@@ -1405,7 +1474,7 @@ pgresult_fields(VALUE self)
  * call-seq:
  *    res.type_map = typemap
  *
- * Set the TypeMap that is used for type casts of result values to ruby objects.
+ * Set the PG::TypeMap that is used for type casts of result values to ruby objects.
  *
  * All value retrieval methods will respect the type map and will do the
  * type casts from PostgreSQL's wire format to Ruby objects on the fly,
@@ -1413,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)
@@ -1435,7 +1505,8 @@ pgresult_type_map_set(VALUE self, VALUE typemap)
  * call-seq:
  *    res.type_map -> value
  *
- * Returns the TypeMap that is currently set for type casts of result values to ruby objects.
+ * 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
@@ -1528,6 +1599,9 @@ 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 LIBPQ_HAS_CHUNK_MODE
+			case PGRES_TUPLES_CHUNK:
+#endif
 				break;
 			default:
 				pg_result_check( self );
@@ -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");
 
@@ -1572,8 +1646,8 @@ pgresult_stream_any(VALUE self, int (*yielder)(VALUE, int, int, void*), void* da
  * wrapping each row into a dedicated result object, it delivers data in nearly
  * the same speed as with ordinary results.
  *
- * The base result must be in status PGRES_SINGLE_TUPLE.
- * It iterates over all tuples until the status changes to PGRES_TUPLES_OK.
+ * The base result must be in status +PGRES_SINGLE_TUPLE+ or +PGRES_TUPLES_CHUNK+.
+ * It iterates over all tuples until the status changes to +PGRES_TUPLES_OK+.
  * A PG::Error is raised for any errors from the server.
  *
  * Row description data does not change while the iteration. All value retrieval
@@ -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);
@@ -1707,10 +1776,8 @@ init_pg_result(void)
 	rb_define_singleton_method(rb_cPGresult, "res_status", pgresult_s_res_status, 1);
 	rb_define_method(rb_cPGresult, "error_message", pgresult_error_message, 0);
 	rb_define_alias( rb_cPGresult, "result_error_message", "error_message");
-#ifdef HAVE_PQRESULTVERBOSEERRORMESSAGE
 	rb_define_method(rb_cPGresult, "verbose_error_message", pgresult_verbose_error_message, 2);
 	rb_define_alias( rb_cPGresult, "result_verbose_error_message", "verbose_error_message");
-#endif
 	rb_define_method(rb_cPGresult, "error_field", pgresult_error_field, 1);
 	rb_define_alias( rb_cPGresult, "result_error_field", "error_field" );
 	rb_define_method(rb_cPGresult, "clear", pg_result_clear, 0);
@@ -1745,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

@@ -579,7 +579,7 @@ pg_text_dec_from_base64(t_pg_coder *conv, const char *val, int len, int tuple, i
 	/* create a buffer of the expected decoded length */
 	VALUE out_value = rb_str_new(NULL, BASE64_DECODED_SIZE(len));
 
-	decoded_len = base64_decode( RSTRING_PTR(out_value), val, len );
+	decoded_len = rbpg_base64_decode( RSTRING_PTR(out_value), val, len );
 	rb_str_set_len(out_value, decoded_len);
 
 	/* Is it a pure String conversion? Then we can directly send out_value to the user. */
@@ -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" );