pg 1.5.4 → 1.6.3

data/ext/pg_copy_coder.c

@@ -51,7 +51,7 @@ static const rb_data_type_t pg_copycoder_type = {
 		pg_copycoder_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_copycoder_memsize,
-		pg_compact_callback(pg_copycoder_compact),
+		pg_copycoder_compact,
 	},
 	&pg_coder_type,
 	0,
@@ -212,6 +212,7 @@ pg_copycoder_type_map_get(VALUE self)
  *
  * See also PG::TextDecoder::CopyRow for the decoding direction with
  * PG::Connection#get_copy_data .
+ * And see PG::BinaryEncoder::CopyRow for an encoder of the COPY binary format.
  */
 static int
 pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
@@ -235,7 +236,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 		char *ptr1;
 		char *ptr2;
 		int strlen;
-		int backslashs;
+		int backslashes;
 		VALUE subint;
 		VALUE entry;
 
@@ -286,19 +287,19 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 					ptr2 = current_out + strlen;
 
 					/* count required backlashs */
-					for(backslashs = 0; ptr1 != ptr2; ptr1++) {
+					for(backslashes = 0; ptr1 != ptr2; ptr1++) {
 						/* Escape backslash itself, newline, carriage return, and the current delimiter character. */
 						if(*ptr1 == '\\' || *ptr1 == '\n' || *ptr1 == '\r' || *ptr1 == this->delimiter){
-							backslashs++;
+							backslashes++;
 						}
 					}
 
 					ptr1 = current_out + strlen;
-					ptr2 = current_out + strlen + backslashs;
+					ptr2 = current_out + strlen + backslashes;
 					current_out = ptr2;
 
 					/* Then store the escaped string on the final position, walking
-					 * right to left, until all backslashs are placed. */
+					 * right to left, until all backslashes are placed. */
 					while( ptr1 != ptr2 ) {
 						*--ptr2 = *--ptr1;
 						if(*ptr1 == '\\' || *ptr1 == '\n' || *ptr1 == '\r' || *ptr1 == this->delimiter){
@@ -358,6 +359,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
  *
  * See also PG::BinaryDecoder::CopyRow for the decoding direction with
  * PG::Connection#get_copy_data .
+ * And see PG::TextEncoder::CopyRow for an encoder of the COPY text format.
  */
 static int
 pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
@@ -391,7 +393,7 @@ pg_bin_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediat
 
 		switch(TYPE(entry)){
 			case T_NIL:
-				/* 4 bytes for -1 indicationg a NULL value */
+				/* 4 bytes for -1 indicating a NULL value */
 				PG_RB_STR_ENSURE_CAPA( *intermediate, 4, current_out, end_capa_ptr );
 				write_nbo32(-1, current_out);
 				current_out += 4;
@@ -496,6 +498,7 @@ GetDecimalFromHex(char hex)
  *
  * See also PG::TextEncoder::CopyRow for the encoding direction with
  * PG::Connection#put_copy_data .
+ * And see PG::BinaryDecoder::CopyRow for a decoder of the COPY binary format.
  */
 /*
  * Parse the current line into separate attributes (fields),
@@ -763,6 +766,7 @@ static const char BinarySignature[11] = "PGCOPY\n\377\r\n\0";
  *
  * See also PG::BinaryEncoder::CopyRow for the encoding direction with
  * PG::Connection#put_copy_data .
+ * And see PG::TextDecoder::CopyRow for a decoder of the COPY text format.
  */
 static VALUE
 pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tuple, int _field, int enc_idx)
@@ -795,26 +799,26 @@ pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tupl
 	cur_ptr = input_line;
 	line_end_ptr = input_line + len;
 
-	if (cur_ptr + 11 <= line_end_ptr && memcmp(cur_ptr, BinarySignature, 11) == 0){
+	if (line_end_ptr - cur_ptr >= 11 && memcmp(cur_ptr, BinarySignature, 11) == 0){
 		/* binary COPY header signature detected -> just drop it */
 		int ext_bytes;
 		cur_ptr += 11;
 
 		/* read flags */
-		if (cur_ptr + 4 > line_end_ptr) goto length_error;
+		if (line_end_ptr - cur_ptr < 4 ) goto length_error;
 		cur_ptr += 4;
 
 		/* read header extensions */
-		if (cur_ptr + 4 > line_end_ptr) goto length_error;
+		if (line_end_ptr - cur_ptr < 4 ) goto length_error;
 		ext_bytes = read_nbo32(cur_ptr);
 		if (ext_bytes < 0) goto length_error;
 		cur_ptr += 4;
-		if (cur_ptr + ext_bytes > line_end_ptr) goto length_error;
+		if (line_end_ptr - cur_ptr < ext_bytes ) goto length_error;
 		cur_ptr += ext_bytes;
 	}
 
 	/* read row header */
-	if (cur_ptr + 2 > line_end_ptr) goto length_error;
+	if (line_end_ptr - cur_ptr < 2 ) goto length_error;
 	nfields = read_nbo16(cur_ptr);
 	cur_ptr += 2;
 
@@ -827,10 +831,9 @@ pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tupl
 
 		for( fieldno = 0; fieldno < nfields; fieldno++){
 			long input_len;
-			VALUE field_value;
 
 			/* read field size */
-			if (cur_ptr + 4 > line_end_ptr) goto length_error;
+			if (line_end_ptr - cur_ptr < 4 ) goto length_error;
 			input_len = read_nbo32(cur_ptr);
 			cur_ptr += 4;
 
@@ -839,7 +842,8 @@ pg_bin_dec_copy_row(t_pg_coder *conv, const char *input_line, int len, int _tupl
 				/* NULL indicator */
 				rb_ary_push(array, Qnil);
 			} else {
-				if (cur_ptr + input_len > line_end_ptr) goto length_error;
+				VALUE field_value;
+				if (line_end_ptr - cur_ptr < input_len ) goto length_error;
 
 				/* copy input data to field_str */
 				PG_RB_STR_ENSURE_CAPA( field_str, input_len, output_ptr, end_capa_ptr );

data/ext/pg_record_coder.c

@@ -43,7 +43,7 @@ static const rb_data_type_t pg_recordcoder_type = {
 		pg_recordcoder_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_recordcoder_memsize,
-		pg_compact_callback(pg_recordcoder_compact),
+		pg_recordcoder_compact,
 	},
 	&pg_coder_type,
 	0,
@@ -198,7 +198,7 @@ pg_text_enc_record(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 		char *ptr1;
 		char *ptr2;
 		long strlen;
-		int backslashs;
+		int backslashes;
 		VALUE subint;
 		VALUE entry;
 
@@ -249,19 +249,19 @@ pg_text_enc_record(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 					ptr2 = current_out + strlen;
 
 					/* count required backlashs */
-					for(backslashs = 0; ptr1 != ptr2; ptr1++) {
+					for(backslashes = 0; ptr1 != ptr2; ptr1++) {
 						/* Escape backslash itself, newline, carriage return, and the current delimiter character. */
 						if(*ptr1 == '"' || *ptr1 == '\\'){
-							backslashs++;
+							backslashes++;
 						}
 					}
 
 					ptr1 = current_out + strlen;
-					ptr2 = current_out + strlen + backslashs;
+					ptr2 = current_out + strlen + backslashes;
 					current_out = ptr2;
 
 					/* Then store the escaped string on the final position, walking
-					 * right to left, until all backslashs are placed. */
+					 * right to left, until all backslashes are placed. */
 					while( ptr1 != ptr2 ) {
 						*--ptr2 = *--ptr1;
 						if(*ptr1 == '"' || *ptr1 == '\\'){
@@ -340,7 +340,7 @@ record_isspace(char ch)
  *   conn.exec("SELECT * FROM my_table").map_types!(PG::TypeMapByColumn.new([deco]*2)).to_a
  *   # => [{"v1"=>[2.0, 3.0], "v2"=>[4.0, 5.0]}, {"v1"=>[6.0, 7.0], "v2"=>[8.0, 9.0]}]
  *
- * It's more very convenient to use the PG::BasicTypeRegistry, which is based on database OIDs.
+ * It's more convenient to use the PG::BasicTypeRegistry, which is based on database OIDs.
  *   # Fetch a NULL record of our type to retrieve the OIDs of the two fields "r" and "i"
  *   oids = conn.exec( "SELECT (NULL::complex).*" )
  *   # Build a type map (PG::TypeMapByColumn) for decoding the "complex" type

data/ext/pg_result.c

@@ -12,6 +12,7 @@ static VALUE sym_symbol, sym_string, sym_static_symbol;
 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,7 +177,7 @@ 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,
@@ -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;
 }
@@ -323,6 +317,9 @@ pg_result_check( VALUE self )
 		case PGRES_COMMAND_OK:
 #ifdef HAVE_PQENTERPIPELINEMODE
 		case PGRES_PIPELINE_SYNC:
+#endif
+#ifdef HAVE_PQSETCHUNKEDROWSMODE
+		case PGRES_TUPLES_CHUNK:
 #endif
 			return self;
 		case PGRES_BAD_RESPONSE:
@@ -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);
 }
@@ -514,20 +512,46 @@ 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]
+ *
+ * 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]
  *
+ * 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,6 +573,7 @@ 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+
  *
@@ -613,14 +638,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 +662,6 @@ pgresult_verbose_error_message(VALUE self, VALUE verbosity, VALUE show_context)
 
 	return ret;
 }
-#endif
 
 /*
  * call-seq:
@@ -664,7 +686,7 @@ pgresult_verbose_error_message(VALUE self, VALUE verbosity, VALUE show_context)
  * An example:
  *
  *   begin
- *       conn.exec( "SELECT * FROM nonexistant_table" )
+ *       conn.exec( "SELECT * FROM nonexistent_table" )
  *   rescue PG::Error => err
  *       p [
  *           err.result.error_field( PG::Result::PG_DIAG_SEVERITY ),
@@ -684,7 +706,7 @@ pgresult_verbose_error_message(VALUE self, VALUE verbosity, VALUE show_context)
  *
  * Outputs:
  *
- *   ["ERROR", "42P01", "relation \"nonexistant_table\" does not exist", nil, nil,
+ *   ["ERROR", "42P01", "relation \"nonexistent_table\" does not exist", nil, nil,
  *    "15", nil, nil, nil, "path/to/parse_relation.c", "857", "parserOpenTable"]
  */
 static VALUE
@@ -708,6 +730,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 +752,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 +766,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 +784,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 +1156,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 +1175,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 +1188,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 +1226,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 +1278,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 +1295,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 +1322,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 +1363,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 +1378,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 +1409,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)
@@ -1389,6 +1435,9 @@ pgresult_each(VALUE self)
  *    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 +1454,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 +1462,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 +1485,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 +1579,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 HAVE_PQSETCHUNKEDROWSMODE
+			case PGRES_TUPLES_CHUNK:
+#endif
 				break;
 			default:
 				pg_result_check( self );
@@ -1572,8 +1626,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
@@ -1707,10 +1761,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);

data/ext/pg_text_decoder.c

@@ -163,6 +163,8 @@ pg_text_dec_integer(t_pg_coder *conv, const char *val, int len, int tuple, int f
  * This is a decoder class for conversion of PostgreSQL numeric types
  * to Ruby BigDecimal objects.
  *
+ * As soon as this class is used, it requires the 'bigdecimal' gem.
+ *
  */
 static VALUE
 pg_text_dec_numeric(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
@@ -174,7 +176,7 @@ pg_text_dec_numeric(t_pg_coder *conv, const char *val, int len, int tuple, int f
 static VALUE
 init_pg_text_decoder_numeric(VALUE rb_mPG_TextDecoder)
 {
-	rb_require("bigdecimal");
+	rb_funcall(rb_mPG, rb_intern("require_bigdecimal_without_warning"), 0);
 	s_id_BigDecimal = rb_intern("BigDecimal");
 
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Numeric", rb_cPG_SimpleDecoder ); */
@@ -577,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. */
@@ -811,6 +813,7 @@ static VALUE pg_text_dec_timestamp(t_pg_coder *conv, const char *val, int len, i
  * This is a decoder class for conversion of PostgreSQL inet type
  * to Ruby IPAddr values.
  *
+ * As soon as this class is used, it requires the ruby standard library 'ipaddr'.
  */
 static VALUE
 pg_text_dec_inet(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)