pg 1.0.0 → 1.5.4

data/ext/pg_result.c

@@ -1,21 +1,196 @@
 /*
  * pg_result.c - PG::Result class extension
- * $Id: pg_result.c,v 7c5d9608349f 2018/01/03 16:11:52 lars $
+ * $Id$
  *
  */
 
 #include "pg.h"
 
-
 VALUE rb_cPGresult;
+static VALUE sym_symbol, sym_string, sym_static_symbol;
 
-static void pgresult_gc_free( t_pg_result * );
 static VALUE pgresult_type_map_set( VALUE, VALUE );
-static VALUE pgresult_s_allocate( VALUE );
 static t_pg_result *pgresult_get_this( VALUE );
 static t_pg_result *pgresult_get_this_safe( VALUE );
 
+#if defined(HAVE_PQRESULTMEMORYSIZE)
+
+static ssize_t
+pgresult_approx_size(const PGresult *result)
+{
+	return PQresultMemorySize(result);
+}
+
+#else
+
+#define PGRESULT_DATA_BLOCKSIZE 2048
+typedef struct pgresAttValue
+{
+	int			len;			/* length in bytes of the value */
+	char	   *value;			/* actual value, plus terminating zero byte */
+} PGresAttValue;
+
 
+static int
+count_leading_zero_bits(unsigned int x)
+{
+#if defined(__GNUC__) || defined(__clang__)
+	return __builtin_clz(x);
+#elif defined(_MSC_VER)
+	DWORD r = 0;
+	_BitScanForward(&r, x);
+	return (int)r;
+#else
+	unsigned int a;
+	for(a=0; a < sizeof(unsigned int) * 8; a++){
+		if( x & (1 << (sizeof(unsigned int) * 8 - 1))) return a;
+		x <<= 1;
+	}
+	return a;
+#endif
+}
+
+static ssize_t
+pgresult_approx_size(const PGresult *result)
+{
+	int num_fields = PQnfields(result);
+	ssize_t size = 0;
+
+	if( num_fields > 0 ){
+		int num_tuples = PQntuples(result);
+
+		if( num_tuples > 0 ){
+			int pos;
+
+			/* This is a simple heuristic to determine the number of sample fields and subsequently to approximate the memory size taken by all field values of the result set.
+			 * Since scanning of all field values is would have a severe performance impact, only a small subset of fields is retrieved and the result is extrapolated to the whole result set.
+			 * The given algorithm has no real scientific background, but is made for speed and typical table layouts.
+			 */
+			int num_samples =
+				(num_fields < 9 ? num_fields : 39 - count_leading_zero_bits(num_fields-8)) *
+				(num_tuples < 8 ? 1 : 30 - count_leading_zero_bits(num_tuples));
+
+			/* start with scanning very last fields, since they are most probably in the cache */
+			for( pos = 0; pos < (num_samples+1)/2; pos++ ){
+				size += PQgetlength(result, num_tuples - 1 - (pos / num_fields), num_fields - 1 - (pos % num_fields));
+			}
+			/* scan the very first fields */
+			for( pos = 0; pos < num_samples/2; pos++ ){
+				size += PQgetlength(result, pos / num_fields, pos % num_fields);
+			}
+			/* extrapolate sample size to whole result set */
+			size = size * num_tuples * num_fields / num_samples;
+		}
+
+		/* count metadata */
+		size += num_fields * (
+				sizeof(PGresAttDesc) + /* column description */
+				num_tuples * (
+					sizeof(PGresAttValue) + 1 /* ptr, len and zero termination of each value */
+				)
+		);
+
+		/* Account free space due to libpq's default block size */
+		size = (size + PGRESULT_DATA_BLOCKSIZE - 1) / PGRESULT_DATA_BLOCKSIZE * PGRESULT_DATA_BLOCKSIZE;
+
+		/* count tuple pointers */
+		size += sizeof(void*) * ((num_tuples + 128 - 1) / 128 * 128);
+	}
+
+	size += 216; /* add PGresult size */
+
+	return size;
+}
+#endif
+
+/*
+ * GC Mark function
+ */
+static void
+pgresult_gc_mark( void *_this )
+{
+	t_pg_result *this = (t_pg_result *)_this;
+	int i;
+
+	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++ ){
+		rb_gc_mark_movable( this->fnames[i] );
+	}
+}
+
+static void
+pgresult_gc_compact( void *_this )
+{
+	t_pg_result *this = (t_pg_result *)_this;
+	int i;
+
+	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++ ){
+		pg_gc_location( this->fnames[i] );
+	}
+}
+
+/*
+ * GC Free function
+ */
+static void
+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;
+	this->pgresult = NULL;
+}
+
+static void
+pgresult_gc_free( void *_this )
+{
+	t_pg_result *this = (t_pg_result *)_this;
+	pgresult_clear( this );
+	xfree(this);
+}
+
+static size_t
+pgresult_memsize( const void *_this )
+{
+	const t_pg_result *this = (const t_pg_result *)_this;
+	/* Ideally the memory 'this' is pointing to should be taken into account as well.
+	 * However we don't want to store two memory sizes in t_pg_result just for reporting by ObjectSpace.memsize_of.
+	 */
+	return this->result_size;
+}
+
+static const rb_data_type_t pgresult_type = {
+	"PG::Result",
+	{
+		pgresult_gc_mark,
+		pgresult_gc_free,
+		pgresult_memsize,
+		pg_compact_callback(pgresult_gc_compact),
+	},
+	0, 0,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+/* Needed by sequel_pg gem, do not delete */
+int pg_get_result_enc_idx(VALUE self)
+{
+	return pgresult_get_this(self)->enc_idx;
+}
 
 /*
  * Global functions
@@ -24,45 +199,91 @@ static t_pg_result *pgresult_get_this_safe( VALUE );
 /*
  * Result constructor
  */
-VALUE
-pg_new_result(PGresult *result, VALUE rb_pgconn)
+static VALUE
+pg_new_result2(PGresult *result, VALUE rb_pgconn)
 {
 	int nfields = result ? PQnfields(result) : 0;
-	VALUE self = pgresult_s_allocate( rb_cPGresult );
+	VALUE self;
 	t_pg_result *this;
 
 	this = (t_pg_result *)xmalloc(sizeof(*this) +  sizeof(*this->fnames) * nfields);
-	DATA_PTR(self) = this;
-
 	this->pgresult = result;
+	/* Initialize connection and typemap prior to any object allocations,
+	 * to make sure valid objects are marked. */
 	this->connection = rb_pgconn;
 	this->typemap = pg_typemap_all_strings;
-	this->p_typemap = DATA_PTR( this->typemap );
-	this->autoclear = 0;
+	this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 	this->nfields = -1;
 	this->tuple_hash = Qnil;
-
-	PG_ENCODING_SET_NOCHECK(self, ENCODING_GET(rb_pgconn));
+	this->field_map = Qnil;
+	this->flags = 0;
+	self = TypedData_Wrap_Struct(rb_cPGresult, &pgresult_type, this);
 
 	if( result ){
 		t_pg_connection *p_conn = pg_get_connection(rb_pgconn);
 		VALUE typemap = p_conn->type_map_for_results;
-
 		/* Type check is done when assigned to PG::Connection. */
-		t_typemap *p_typemap = DATA_PTR(typemap);
-
-		this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
-		this->p_typemap = DATA_PTR( this->typemap );
+		t_typemap *p_typemap = RTYPEDDATA_DATA(typemap);
+
+		this->enc_idx = p_conn->enc_idx;
+		typemap = p_typemap->funcs.fit_to_result( typemap, self );
+		RB_OBJ_WRITE(self, &this->typemap, typemap);
+		this->p_typemap = RTYPEDDATA_DATA( this->typemap );
+		this->flags = p_conn->flags;
+	} else {
+		this->enc_idx = rb_locale_encindex();
 	}
 
 	return self;
 }
 
+VALUE
+pg_new_result(PGresult *result, VALUE rb_pgconn)
+{
+	VALUE self = pg_new_result2(result, rb_pgconn);
+	t_pg_result *this = pgresult_get_this(self);
+
+	this->autoclear = 0;
+
+	/* Estimate size of underlying pgresult memory storage and account to ruby GC.
+	 * There's no need to adjust the GC for xmalloc'ed memory, but libpq is using libc malloc() ruby doesn't know about.
+	 */
+	/* TODO: If someday most systems provide PQresultMemorySize(), it's questionable to store result_size in t_pg_result in addition to the value already stored in PGresult.
+	 * For now the memory savings don't justify the ifdefs necessary to support both cases.
+	 */
+	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;
+}
+
+static VALUE
+pg_copy_result(t_pg_result *this)
+{
+	int nfields = this->nfields == -1 ? (this->pgresult ? PQnfields(this->pgresult) : 0) : this->nfields;
+	size_t len = sizeof(*this) +  sizeof(*this->fnames) * nfields;
+	t_pg_result *copy;
+
+	copy = (t_pg_result *)xmalloc(len);
+	memcpy(copy, this, len);
+	this->result_size = 0;
+
+	return TypedData_Wrap_Struct(rb_cPGresult, &pgresult_type, copy);
+}
+
 VALUE
 pg_new_result_autoclear(PGresult *result, VALUE rb_pgconn)
 {
-	VALUE self = pg_new_result(result, rb_pgconn);
+	VALUE self = pg_new_result2(result, rb_pgconn);
 	t_pg_result *this = pgresult_get_this(self);
+
+	/* Autocleared results are freed implicit instead of by PQclear().
+	 * So it's not very useful to be accounted by ruby GC.
+	 */
+	this->result_size = 0;
 	this->autoclear = 1;
 	return self;
 }
@@ -71,7 +292,11 @@ pg_new_result_autoclear(PGresult *result, VALUE rb_pgconn)
  * call-seq:
  *    res.check -> nil
  *
- * Raises appropriate exception if PG::Result is in a bad state.
+ * Raises appropriate exception if PG::Result is in a bad state, which is:
+ * * +PGRES_BAD_RESPONSE+
+ * * +PGRES_FATAL_ERROR+
+ * * +PGRES_NONFATAL_ERROR+
+ * * +PGRES_PIPELINE_ABORTED+
  */
 VALUE
 pg_result_check( VALUE self )
@@ -96,10 +321,16 @@ pg_result_check( VALUE self )
 		case PGRES_SINGLE_TUPLE:
 		case PGRES_EMPTY_QUERY:
 		case PGRES_COMMAND_OK:
+#ifdef HAVE_PQENTERPIPELINEMODE
+		case PGRES_PIPELINE_SYNC:
+#endif
 			return self;
 		case PGRES_BAD_RESPONSE:
 		case PGRES_FATAL_ERROR:
 		case PGRES_NONFATAL_ERROR:
+#ifdef HAVE_PQENTERPIPELINEMODE
+		case PGRES_PIPELINE_ABORTED:
+#endif
 			error = rb_str_new2( PQresultErrorMessage(this->pgresult) );
 			break;
 		default:
@@ -107,7 +338,7 @@ pg_result_check( VALUE self )
 		}
 	}
 
-	PG_ENCODING_SET_NOCHECK( error, ENCODING_GET(self) );
+	PG_ENCODING_SET_NOCHECK( error, this->enc_idx );
 
 	sqlstate = PQresultErrorField( this->pgresult, PG_DIAG_SQLSTATE );
 	klass = lookup_error_class( sqlstate );
@@ -131,29 +362,52 @@ pg_result_check( VALUE self )
  * call-seq:
  *    res.clear() -> nil
  *
- * Clears the PG::Result object as the result of the query.
+ * Clears the PG::Result object as the result of a query.
+ * This frees all underlying memory consumed by the result object.
+ * Afterwards access to result methods raises PG::Error "result has been cleared".
+ *
+ * Explicit calling #clear can lead to better memory performance, but is not generally necessary.
+ * Special care must be taken when PG::Tuple objects are used.
+ * In this case #clear must not be called unless all PG::Tuple objects of this result are fully materialized.
  *
- * If PG::Result#autoclear? is true then the result is marked as cleared
- * and the underlying C struct will be cleared automatically by libpq.
+ * If PG::Result#autoclear? is +true+ then the result is only marked as cleared but clearing the underlying C struct will happen when the callback returns.
  *
  */
 VALUE
 pg_result_clear(VALUE self)
 {
 	t_pg_result *this = pgresult_get_this(self);
-	if( !this->autoclear )
-		PQclear(pgresult_get(self));
-	this->pgresult = NULL;
+	rb_check_frozen(self);
+	pgresult_clear( this );
 	return Qnil;
 }
 
+/*
+ * call-seq:
+ *    res.freeze
+ *
+ * Freeze the PG::Result object and unlink the result from the related PG::Connection.
+ *
+ * A frozen PG::Result object doesn't allow any streaming and it can't be cleared.
+ * It also denies setting a type_map or field_name_type.
+ *
+ */
+static VALUE
+pg_result_freeze(VALUE self)
+{
+	t_pg_result *this = pgresult_get_this(self);
+
+	RB_OBJ_WRITE(self, &this->connection, Qnil);
+	return rb_call_super(0, NULL);
+}
+
 /*
  * call-seq:
  *    res.cleared?      -> boolean
  *
- * Returns +true+ if the backend result memory has been free'd.
+ * Returns +true+ if the backend result memory has been freed.
  */
-VALUE
+static VALUE
 pgresult_cleared_p( VALUE self )
 {
 	t_pg_result *this = pgresult_get_this(self);
@@ -164,11 +418,13 @@ pgresult_cleared_p( VALUE self )
  * call-seq:
  *    res.autoclear?      -> boolean
  *
- * Returns +true+ if the underlying C struct will be cleared automatically by libpq.
- * Elsewise the result is cleared by PG::Result#clear or by the GC when it's no longer in use.
+ * Returns +true+ if the underlying C struct will be cleared at the end of a callback.
+ * This applies only to Result objects received by the block to PG::Connection#set_notice_receiver .
+ *
+ * All other Result objects are automatically cleared by the GC when the object is no longer in use or manually by PG::Result#clear .
  *
  */
-VALUE
+static VALUE
 pgresult_autoclear_p( VALUE self )
 {
 	t_pg_result *this = pgresult_get_this(self);
@@ -179,37 +435,6 @@ pgresult_autoclear_p( VALUE self )
  * DATA pointer functions
  */
 
-/*
- * GC Mark function
- */
-static void
-pgresult_gc_mark( t_pg_result *this )
-{
-	int i;
-
-	if( !this ) return;
-	rb_gc_mark( this->connection );
-	rb_gc_mark( this->typemap );
-	rb_gc_mark( this->tuple_hash );
-
-	for( i=0; i < this->nfields; i++ ){
-		rb_gc_mark( this->fnames[i] );
-	}
-}
-
-/*
- * GC Free function
- */
-static void
-pgresult_gc_free( t_pg_result *this )
-{
-	if( !this ) return;
-	if(this->pgresult != NULL && !this->autoclear)
-		PQclear(this->pgresult);
-
-	xfree(this);
-}
-
 /*
  * Fetch the PG::Result object data pointer and check it's
  * PGresult data pointer for sanity.
@@ -239,18 +464,30 @@ pgresult_get(VALUE self)
 	return this->pgresult;
 }
 
-/*
- * Document-method: allocate
- *
- * call-seq:
- *   PG::Result.allocate -> result
- */
-static VALUE
-pgresult_s_allocate( VALUE klass )
+static VALUE pg_cstr_to_sym(char *cstr, unsigned int flags, int enc_idx)
 {
-	VALUE self = Data_Wrap_Struct( klass, pgresult_gc_mark, pgresult_gc_free, NULL );
-
-	return self;
+	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);
+		if( fname == Qnil ){
+			fname = rb_str_new2(cstr);
+			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);
+	}
+	return fname;
 }
 
 static void pgresult_init_fnames(VALUE self)
@@ -262,12 +499,10 @@ static void pgresult_init_fnames(VALUE self)
 		int nfields = PQnfields(this->pgresult);
 
 		for( i=0; i<nfields; i++ ){
-			VALUE fname = rb_tainted_str_new2(PQfname(this->pgresult, i));
-			PG_ENCODING_SET_NOCHECK(fname, ENCODING_GET(self));
-			this->fnames[i] = rb_obj_freeze(fname);
+			char *cfname = PQfname(this->pgresult, i);
+			VALUE fname = pg_cstr_to_sym(cfname, this->flags, this->enc_idx);
+			RB_OBJ_WRITE(self, &this->fnames[i], fname);
 			this->nfields = i + 1;
-
-			RB_GC_GUARD(fname);
 		}
 		this->nfields = nfields;
 	}
@@ -279,8 +514,11 @@ 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.
- * You may need to invoke the #clear method of the instance when finished with
- * the result for better memory performance.
+ * 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.
  *
  * Example:
  *    require 'pg'
@@ -310,6 +548,11 @@ static void pgresult_init_fnames(VALUE self)
  * * +PGRES_NONFATAL_ERROR+
  * * +PGRES_FATAL_ERROR+
  * * +PGRES_COPY_BOTH+
+ * * +PGRES_SINGLE_TUPLE+
+ * * +PGRES_PIPELINE_SYNC+
+ * * +PGRES_PIPELINE_ABORTED+
+ *
+ * Use <tt>res.res_status</tt> to retrieve the string representation.
  */
 static VALUE
 pgresult_result_status(VALUE self)
@@ -319,16 +562,39 @@ pgresult_result_status(VALUE self)
 
 /*
  * call-seq:
- *    res.res_status( status ) -> String
+ *    PG::Result.res_status( status ) -> String
  *
- * Returns the string representation of status +status+.
+ * Returns the string representation of +status+.
  *
 */
 static VALUE
-pgresult_res_status(VALUE self, VALUE status)
+pgresult_s_res_status(VALUE self, VALUE status)
 {
-	VALUE ret = rb_tainted_str_new2(PQresStatus(NUM2INT(status)));
-	PG_ENCODING_SET_NOCHECK(ret, ENCODING_GET(self));
+	return rb_utf8_str_new_cstr(PQresStatus(NUM2INT(status)));
+}
+
+/*
+ * call-seq:
+ *    res.res_status -> String
+ *    res.res_status( status ) -> String
+ *
+ * Returns the string representation of the status of the result or of the provided +status+.
+ *
+ */
+static VALUE
+pgresult_res_status(int argc, VALUE *argv, VALUE self)
+{
+	t_pg_result *this = pgresult_get_this_safe(self);
+	VALUE ret;
+
+	if( argc == 0 ){
+		ret = rb_str_new2(PQresStatus(PQresultStatus(this->pgresult)));
+	}else if( argc == 1 ){
+		ret = rb_str_new2(PQresStatus(NUM2INT(argv[0])));
+	}else{
+		rb_raise(rb_eArgError, "only 0 or 1 arguments expected");
+	}
+	PG_ENCODING_SET_NOCHECK(ret, this->enc_idx);
 	return ret;
 }
 
@@ -341,10 +607,39 @@ pgresult_res_status(VALUE self, VALUE status)
 static VALUE
 pgresult_error_message(VALUE self)
 {
-	VALUE ret = rb_tainted_str_new2(PQresultErrorMessage(pgresult_get(self)));
-	PG_ENCODING_SET_NOCHECK(ret, ENCODING_GET(self));
+	t_pg_result *this = pgresult_get_this_safe(self);
+	VALUE ret = rb_str_new2(PQresultErrorMessage(this->pgresult));
+	PG_ENCODING_SET_NOCHECK(ret, this->enc_idx);
+	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.
+ *
+ * Available since PostgreSQL-9.6
+ */
+static VALUE
+pgresult_verbose_error_message(VALUE self, VALUE verbosity, VALUE show_context)
+{
+	t_pg_result *this = pgresult_get_this_safe(self);
+	VALUE ret;
+	char *c_str;
+
+	c_str = PQresultVerboseErrorMessage(this->pgresult, NUM2INT(verbosity), NUM2INT(show_context));
+	if(!c_str)
+		rb_raise(rb_eNoMemError, "insufficient memory to format error message");
+
+	ret = rb_str_new2(c_str);
+	PQfreemem(c_str);
+	PG_ENCODING_SET_NOCHECK(ret, this->enc_idx);
+
 	return ret;
 }
+#endif
 
 /*
  * call-seq:
@@ -395,14 +690,14 @@ pgresult_error_message(VALUE self)
 static VALUE
 pgresult_error_field(VALUE self, VALUE field)
 {
-	PGresult *result = pgresult_get( self );
+	t_pg_result *this = pgresult_get_this_safe(self);
 	int fieldcode = NUM2INT( field );
-	char * fieldstr = PQresultErrorField( result, fieldcode );
+	char * fieldstr = PQresultErrorField( this->pgresult, fieldcode );
 	VALUE ret = Qnil;
 
 	if ( fieldstr ) {
-		ret = rb_tainted_str_new2( fieldstr );
-		PG_ENCODING_SET_NOCHECK( ret, ENCODING_GET(self ));
+		ret = rb_str_new2( fieldstr );
+		PG_ENCODING_SET_NOCHECK( ret, this->enc_idx );
 	}
 
 	return ret;
@@ -423,7 +718,7 @@ pgresult_ntuples(VALUE self)
 static VALUE
 pgresult_ntuples_for_enum(VALUE self, VALUE args, VALUE eobj)
 {
-    return pgresult_ntuples(self);
+	return pgresult_ntuples(self);
 }
 
 /*
@@ -440,24 +735,40 @@ pgresult_nfields(VALUE self)
 
 /*
  * call-seq:
- *    res.fname( index ) -> String
+ *    res.binary_tuples() -> Integer
+ *
+ * Returns 1 if the PGresult 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.
+ * Result#fformat is preferred. binary_tuples returns 1 only if all columns of the result are binary (format 1).
+ */
+static VALUE
+pgresult_binary_tuples(VALUE self)
+{
+	return INT2NUM(PQbinaryTuples(pgresult_get(self)));
+}
+
+/*
+ * call-seq:
+ *    res.fname( index ) -> String or Symbol
  *
  * Returns the name of the column corresponding to _index_.
+ * Depending on #field_name_type= it's a String or Symbol.
+ *
  */
 static VALUE
 pgresult_fname(VALUE self, VALUE index)
 {
-	VALUE fname;
-	PGresult *result = pgresult_get(self);
+	t_pg_result *this = pgresult_get_this_safe(self);
 	int i = NUM2INT(index);
+	char *cfname;
 
-	if (i < 0 || i >= PQnfields(result)) {
+	if (i < 0 || i >= PQnfields(this->pgresult)) {
 		rb_raise(rb_eArgError,"invalid field number %d", i);
 	}
 
-	fname = rb_tainted_str_new2(PQfname(result, i));
-	PG_ENCODING_SET_NOCHECK(fname, ENCODING_GET(self));
-	return rb_obj_freeze(fname);
+	cfname = PQfname(this->pgresult, i);
+	return pg_cstr_to_sym(cfname, this->flags, this->enc_idx);
 }
 
 /*
@@ -756,8 +1067,9 @@ pgresult_paramtype(VALUE self, VALUE param_number)
 static VALUE
 pgresult_cmd_status(VALUE self)
 {
-	VALUE ret = rb_tainted_str_new2(PQcmdStatus(pgresult_get(self)));
-	PG_ENCODING_SET_NOCHECK(ret, ENCODING_GET(self));
+	t_pg_result *this = pgresult_get_this_safe(self);
+	VALUE ret = rb_str_new2(PQcmdStatus(this->pgresult));
+	PG_ENCODING_SET_NOCHECK(ret, this->enc_idx);
 	return ret;
 }
 
@@ -786,7 +1098,7 @@ pgresult_cmd_tuples(VALUE self)
 {
 	long n;
 	n = strtol(PQcmdTuples(pgresult_get(self)),NULL, 10);
-	return INT2NUM(n);
+	return LONG2NUM(n);
 }
 
 /*
@@ -838,7 +1150,7 @@ pgresult_aref(VALUE self, VALUE index)
 	}
 	/* Store a copy of the filled hash for use at the next row. */
 	if( num_tuples > 10 )
-		this->tuple_hash = rb_hash_dup(tuple);
+		RB_OBJ_WRITE(self, &this->tuple_hash, rb_hash_dup(tuple));
 
 	return tuple;
 }
@@ -957,8 +1269,12 @@ static VALUE
 pgresult_field_values( VALUE self, VALUE field )
 {
 	PGresult *result = pgresult_get( self );
-	const char *fieldname = StringValueCStr( field );
-	int fnum = PQfnumber( result, fieldname );
+	const char *fieldname;
+	int fnum;
+
+	if( RB_TYPE_P(field, T_SYMBOL) ) field = rb_sym_to_s( field );
+	fieldname = StringValueCStr( field );
+	fnum = PQfnumber( result, fieldname );
 
 	if ( fnum < 0 )
 		rb_raise( rb_eIndexError, "no such field '%s' in result", fieldname );
@@ -967,6 +1283,85 @@ pgresult_field_values( VALUE self, VALUE field )
 }
 
 
+/*
+ *  call-seq:
+ *     res.tuple_values( n )   -> array
+ *
+ *  Returns an Array of the field values from the nth row of the result.
+ *
+ */
+static VALUE
+pgresult_tuple_values(VALUE self, VALUE index)
+{
+	int tuple_num = NUM2INT( index );
+	t_pg_result *this;
+	int field;
+	int num_tuples;
+	int num_fields;
+
+	this = pgresult_get_this_safe(self);
+	num_tuples = PQntuples(this->pgresult);
+	num_fields = PQnfields(this->pgresult);
+
+	if ( tuple_num < 0 || tuple_num >= num_tuples )
+		rb_raise( rb_eIndexError, "Index %d is out of range", tuple_num );
+
+	{
+		PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, num_fields, PG_MAX_COLUMNS)
+
+		/* populate the row */
+		for ( field = 0; field < num_fields; field++ ) {
+			row_values[field] = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, tuple_num, field);
+		}
+		return rb_ary_new4( num_fields, row_values );
+	}
+}
+
+static void ensure_init_for_tuple(VALUE self)
+{
+	t_pg_result *this = pgresult_get_this_safe(self);
+
+	if( this->field_map == Qnil ){
+		int i;
+		VALUE field_map = rb_hash_new();
+
+		if( this->nfields == -1 )
+			pgresult_init_fnames( self );
+
+		for( i = 0; i < this->nfields; i++ ){
+			rb_hash_aset(field_map, this->fnames[i], INT2FIX(i));
+		}
+		rb_obj_freeze(field_map);
+		RB_OBJ_WRITE(self, &this->field_map, field_map);
+	}
+}
+
+/*
+ *  call-seq:
+ *     res.tuple( n )   -> PG::Tuple
+ *
+ *  Returns a PG::Tuple from the nth row of the result.
+ *
+ */
+static VALUE
+pgresult_tuple(VALUE self, VALUE index)
+{
+	int tuple_num = NUM2INT( index );
+	t_pg_result *this;
+	int num_tuples;
+
+	this = pgresult_get_this_safe(self);
+	num_tuples = PQntuples(this->pgresult);
+
+	if ( tuple_num < 0 || tuple_num >= num_tuples )
+		rb_raise( rb_eIndexError, "Index %d is out of range", tuple_num );
+
+	ensure_init_for_tuple(self);
+
+  return pg_tuple_new(self, tuple_num);
+}
+
+
 /*
  * call-seq:
  *    res.each{ |tuple| ... }
@@ -993,7 +1388,7 @@ pgresult_each(VALUE self)
  * call-seq:
  *    res.fields() -> Array
  *
- * Returns an array of Strings representing the names of the fields in the result.
+ * Depending on #field_name_type= returns an array of strings or symbols representing the names of the fields in the result.
  */
 static VALUE
 pgresult_fields(VALUE self)
@@ -1025,14 +1420,13 @@ pgresult_type_map_set(VALUE self, VALUE typemap)
 	t_pg_result *this = pgresult_get_this(self);
 	t_typemap *p_typemap;
 
-	if ( !rb_obj_is_kind_of(typemap, rb_cTypeMap) ) {
-		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::TypeMap)",
-				rb_obj_classname( typemap ) );
-	}
-	Data_Get_Struct(typemap, t_typemap, p_typemap);
+	rb_check_frozen(self);
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, p_typemap);
 
-	this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
-	this->p_typemap = DATA_PTR( this->typemap );
+	typemap = p_typemap->funcs.fit_to_result( typemap, self );
+	RB_OBJ_WRITE(self, &this->typemap, typemap);
+	this->p_typemap = RTYPEDDATA_DATA( typemap );
 
 	return typemap;
 }
@@ -1052,47 +1446,71 @@ pgresult_type_map_get(VALUE self)
 	return this->typemap;
 }
 
-/*
- * call-seq:
- *    res.stream_each{ |tuple| ... }
- *
- * Invokes block for each tuple in the result set in single row mode.
- *
- * This is a convenience method for retrieving all result tuples
- * as they are transferred. It is an alternative to repeated calls of
- * PG::Connection#get_result , but given that it avoids the overhead of
- * wrapping each row into a dedicated result object, it delivers data in nearly
- * the same speed as with ordinary results.
- *
- * The result must be in status PGRES_SINGLE_TUPLE.
- * 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
- * methods refer to only the current row. Result#ntuples returns +1+ while
- * the iteration and +0+ after all tuples were yielded.
- *
- * Example:
- *   conn.send_query( "first SQL query; second SQL query" )
- *   conn.set_single_row_mode
- *   conn.get_result.stream_each do |row|
- *     # do something with the received row of the first query
- *   end
- *   conn.get_result.stream_each do |row|
- *     # do something with the received row of the second query
- *   end
- *   conn.get_result  # => nil   (no more results)
- *
- * Available since PostgreSQL-9.2
- */
-static VALUE
-pgresult_stream_each(VALUE self)
+
+static int
+yield_hash(VALUE self, int ntuples, int nfields, void *data)
+{
+	int tuple_num;
+	UNUSED(nfields);
+
+	for(tuple_num = 0; tuple_num < ntuples; tuple_num++) {
+		rb_yield(pgresult_aref(self, INT2NUM(tuple_num)));
+	}
+
+	return 1; /* clear the result */
+}
+
+static int
+yield_array(VALUE self, int ntuples, int nfields, void *data)
+{
+	int row;
+	t_pg_result *this = pgresult_get_this(self);
+
+	for ( row = 0; row < ntuples; row++ ) {
+		PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, nfields, PG_MAX_COLUMNS)
+		int field;
+
+		/* populate the row */
+		for ( field = 0; field < nfields; field++ ) {
+			row_values[field] = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, row, field);
+		}
+		rb_yield( rb_ary_new4( nfields, row_values ));
+	}
+
+	return 1; /* clear the result */
+}
+
+static int
+yield_tuple(VALUE self, int ntuples, int nfields, void *data)
+{
+	int tuple_num;
+	t_pg_result *this = pgresult_get_this(self);
+	VALUE copy;
+	UNUSED(nfields);
+
+	/* make a copy of the base result, that is bound to the PG::Tuple */
+	copy = pg_copy_result(this);
+	/* The copy is now owner of the PGresult and is responsible to PQclear it.
+	 * We clear the pgresult here, so that it's not double freed on error within yield. */
+	this->pgresult = NULL;
+
+	for(tuple_num = 0; tuple_num < ntuples; tuple_num++) {
+		VALUE tuple = pgresult_tuple(copy, INT2FIX(tuple_num));
+		rb_yield( tuple );
+	}
+	return 0; /* don't clear the result */
+}
+
+/* Non-static, and data pointer for use by sequel_pg */
+VALUE
+pgresult_stream_any(VALUE self, int (*yielder)(VALUE, int, int, void*), void* data)
 {
 	t_pg_result *this;
-	int nfields;
+	int nfields, nfields2;
 	PGconn *pgconn;
 	PGresult *pgresult;
 
+	rb_check_frozen(self);
 	RETURN_ENUMERATOR(self, 0, NULL);
 
 	this = pgresult_get_this_safe(self);
@@ -1101,11 +1519,11 @@ pgresult_stream_each(VALUE self)
 	nfields = PQnfields(pgresult);
 
 	for(;;){
-		int tuple_num;
 		int ntuples = PQntuples(pgresult);
 
 		switch( PQresultStatus(pgresult) ){
 			case PGRES_TUPLES_OK:
+			case PGRES_COMMAND_OK:
 				if( ntuples == 0 )
 					return self;
 				rb_raise( rb_eInvalidResultStatus, "PG::Result is not in single row mode");
@@ -1115,21 +1533,24 @@ pgresult_stream_each(VALUE self)
 				pg_result_check( self );
 		}
 
-		for(tuple_num = 0; tuple_num < ntuples; tuple_num++) {
-			rb_yield(pgresult_aref(self, INT2NUM(tuple_num)));
+		nfields2 = PQnfields(pgresult);
+		if( nfields != nfields2 ){
+			pgresult_clear( this );
+			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields changed in single row mode from %d to %d - this is a sign for intersection with another query", nfields, nfields2);
+		}
+
+		if( yielder( self, ntuples, nfields, data ) ){
+			pgresult_clear( this );
 		}
 
-		if( !this->autoclear ){
-			PQclear( pgresult );
-			this->pgresult = NULL;
+		if( gvl_PQisBusy(pgconn) ){
+			/* wait for input (without blocking) before reading each result */
+			pgconn_block( 0, NULL, this->connection );
 		}
 
 		pgresult = gvl_PQgetResult(pgconn);
 		if( pgresult == NULL )
-			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another result retrieval");
-
-		if( nfields != PQnfields(pgresult) )
-			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields must not change in single row mode");
+			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another query");
 
 		this->pgresult = pgresult;
 	}
@@ -1138,6 +1559,44 @@ pgresult_stream_each(VALUE self)
 	return self;
 }
 
+
+/*
+ * call-seq:
+ *    res.stream_each{ |tuple| ... }
+ *
+ * Invokes block for each tuple in the result set in single row mode.
+ *
+ * This is a convenience method for retrieving all result tuples
+ * as they are transferred. It is an alternative to repeated calls of
+ * PG::Connection#get_result , but given that it avoids the overhead of
+ * 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.
+ * A PG::Error is raised for any errors from the server.
+ *
+ * Row description data does not change while the iteration. All value retrieval
+ * methods refer to only the current row. Result#ntuples returns +1+ while
+ * the iteration and +0+ after all tuples were yielded.
+ *
+ * Example:
+ *   conn.send_query( "first SQL query; second SQL query" )
+ *   conn.set_single_row_mode
+ *   conn.get_result.stream_each do |row|
+ *     # do something with each received row of the first query
+ *   end
+ *   conn.get_result.stream_each do |row|
+ *     # do something with each received row of the second query
+ *   end
+ *   conn.get_result  # => nil   (no more results)
+ */
+static VALUE
+pgresult_stream_each(VALUE self)
+{
+	return pgresult_stream_any(self, yield_hash, NULL);
+}
+
 /*
  * call-seq:
  *    res.stream_each_row { |row| ... }
@@ -1147,92 +1606,122 @@ pgresult_stream_each(VALUE self)
  *
  * This method works equally to #stream_each , but yields an Array of
  * values.
- *
- * Available since PostgreSQL-9.2
  */
 static VALUE
 pgresult_stream_each_row(VALUE self)
 {
-	t_pg_result *this;
-	int row;
-	int nfields;
-	PGconn *pgconn;
-	PGresult *pgresult;
-
-	RETURN_ENUMERATOR(self, 0, NULL);
-
-	this = pgresult_get_this_safe(self);
-	pgconn = pg_get_pgconn(this->connection);
-	pgresult = this->pgresult;
-	nfields = PQnfields(pgresult);
-
-	for(;;){
-		int ntuples = PQntuples(pgresult);
+	return pgresult_stream_any(self, yield_array, NULL);
+}
 
-		switch( PQresultStatus(pgresult) ){
-			case PGRES_TUPLES_OK:
-				if( ntuples == 0 )
-					return self;
-				rb_raise( rb_eInvalidResultStatus, "PG::Result is not in single row mode");
-			case PGRES_SINGLE_TUPLE:
-				break;
-			default:
-				pg_result_check( self );
-		}
+/*
+ * call-seq:
+ *    res.stream_each_tuple { |tuple| ... }
+ *
+ * Yields each row of the result set in single row mode.
+ *
+ * This method works equally to #stream_each , but yields a PG::Tuple object.
+ */
+static VALUE
+pgresult_stream_each_tuple(VALUE self)
+{
+	/* allocate VALUEs that are shared between all streamed tuples */
+	ensure_init_for_tuple(self);
 
-		for ( row = 0; row < ntuples; row++ ) {
-			PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, nfields, PG_MAX_COLUMNS)
-			int field;
+	return pgresult_stream_any(self, yield_tuple, NULL);
+}
 
-			/* populate the row */
-			for ( field = 0; field < nfields; field++ ) {
-				row_values[field] = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, row, field);
-			}
-			rb_yield( rb_ary_new4( nfields, row_values ));
-		}
+/*
+ * call-seq:
+ *    res.field_name_type = Symbol
+ *
+ * Set type of field names specific to this result.
+ * 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+ .
+ *
+ * This setting affects several result methods:
+ * * keys of Hash returned by #[] , #each and #stream_each
+ * * #fields
+ * * #fname
+ * * field names used by #tuple and #stream_each_tuple
+ *
+ * The type of field names can only be changed before any of the affected methods have been called.
+ *
+ */
+static VALUE
+pgresult_field_name_type_set(VALUE self, VALUE sym)
+{
+	t_pg_result *this = pgresult_get_this(self);
 
-		if( !this->autoclear ){
-			PQclear( pgresult );
-			this->pgresult = NULL;
-		}
+	rb_check_frozen(self);
+	if( this->nfields != -1 ) rb_raise(rb_eArgError, "field names are already materialized");
 
-		pgresult = gvl_PQgetResult(pgconn);
-		if( pgresult == NULL )
-			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another result retrieval");
+	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);
 
-		if( nfields != PQnfields(pgresult) )
-			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields must not change in single row mode");
+	return sym;
+}
 
-		this->pgresult = pgresult;
+/*
+ * call-seq:
+ *    res.field_name_type -> Symbol
+ *
+ * Get type of field names.
+ *
+ * See description at #field_name_type=
+ */
+static VALUE
+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;
 	}
-
-	/* never reached */
-	return self;
 }
 
-
 void
-init_pg_result()
+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_define_alloc_func( rb_cPGresult, pgresult_s_allocate );
+	rb_undef_alloc_func(rb_cPGresult);
 	rb_include_module(rb_cPGresult, rb_mEnumerable);
 	rb_include_module(rb_cPGresult, rb_mPGconstants);
 
 	/******     PG::Result INSTANCE METHODS: libpq     ******/
 	rb_define_method(rb_cPGresult, "result_status", pgresult_result_status, 0);
-	rb_define_method(rb_cPGresult, "res_status", pgresult_res_status, 1);
+	rb_define_method(rb_cPGresult, "res_status", pgresult_res_status, -1);
+	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);
+	rb_define_method(rb_cPGresult, "freeze", pg_result_freeze, 0 );
 	rb_define_method(rb_cPGresult, "check", pg_result_check, 0);
 	rb_define_alias (rb_cPGresult, "check_result", "check");
 	rb_define_method(rb_cPGresult, "ntuples", pgresult_ntuples, 0);
 	rb_define_alias(rb_cPGresult, "num_tuples", "ntuples");
 	rb_define_method(rb_cPGresult, "nfields", pgresult_nfields, 0);
 	rb_define_alias(rb_cPGresult, "num_fields", "nfields");
+	rb_define_method(rb_cPGresult, "binary_tuples", pgresult_binary_tuples, 0);
 	rb_define_method(rb_cPGresult, "fname", pgresult_fname, 1);
 	rb_define_method(rb_cPGresult, "fnumber", pgresult_fnumber, 1);
 	rb_define_method(rb_cPGresult, "ftable", pgresult_ftable, 1);
@@ -1259,6 +1748,8 @@ init_pg_result()
 	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);
+	rb_define_method(rb_cPGresult, "tuple_values", pgresult_tuple_values, 1);
+	rb_define_method(rb_cPGresult, "tuple", pgresult_tuple, 1);
 	rb_define_method(rb_cPGresult, "cleared?", pgresult_cleared_p, 0);
 	rb_define_method(rb_cPGresult, "autoclear?", pgresult_autoclear_p, 0);
 
@@ -1268,6 +1759,8 @@ init_pg_result()
 	/******     PG::Result INSTANCE METHODS: streaming     ******/
 	rb_define_method(rb_cPGresult, "stream_each", pgresult_stream_each, 0);
 	rb_define_method(rb_cPGresult, "stream_each_row", pgresult_stream_each_row, 0);
-}
-
+	rb_define_method(rb_cPGresult, "stream_each_tuple", pgresult_stream_each_tuple, 0);
 
+	rb_define_method(rb_cPGresult, "field_name_type=", pgresult_field_name_type_set, 1 );
+	rb_define_method(rb_cPGresult, "field_name_type", pgresult_field_name_type_get, 0 );
+}