pg 0.18.0.pre20141017160319-x64-mingw32 → 0.18.0.pre20141117110243-x64-mingw32

data/ext/pg_copy_coder.c

@@ -33,7 +33,7 @@ pg_copycoder_encoder_allocate( VALUE klass )
 	t_pg_copycoder *this;
 	VALUE self = Data_Make_Struct( klass, t_pg_copycoder, pg_copycoder_mark, -1, this );
 	pg_coder_init_encoder( self );
-	this->typemap = Qnil;
+	this->typemap = pg_typemap_all_strings;
 	this->delimiter = '\t';
 	this->null_string = rb_str_new_cstr("\\N");
 	return self;
@@ -45,7 +45,7 @@ pg_copycoder_decoder_allocate( VALUE klass )
 	t_pg_copycoder *this;
 	VALUE self = Data_Make_Struct( klass, t_pg_copycoder, pg_copycoder_mark, -1, this );
 	pg_coder_init_decoder( self );
-	this->typemap = Qnil;
+	this->typemap = pg_typemap_all_strings;
 	this->delimiter = '\t';
 	this->null_string = rb_str_new_cstr("\\N");
 	return self;
@@ -112,10 +112,10 @@ pg_copycoder_null_string_get(VALUE self)
  * call-seq:
  *    coder.type_map = map
  *
- * +map+ can be:
- * * a kind of PG::TypeMap
- * * +nil+ - use PG::TextEncoder::String respectively PG::TextDecoder::String
- *   for encoding/decoding of all columns.
+ * +map+ must be a kind of PG::TypeMap .
+ *
+ * Defaults to a PG::TypeMapAllStrings , so that PG::TextEncoder::String respectively
+ * PG::TextDecoder::String is used for encoding/decoding of all columns.
  *
  */
 static VALUE
@@ -123,7 +123,7 @@ pg_copycoder_type_map_set(VALUE self, VALUE type_map)
 {
 	t_pg_copycoder *this = DATA_PTR( self );
 
-	if ( !NIL_P(type_map) && !rb_obj_is_kind_of(type_map, rb_cTypeMap) ){
+	if ( !rb_obj_is_kind_of(type_map, rb_cTypeMap) ){
 		rb_raise( rb_eTypeError, "wrong elements type %s (expected some kind of PG::TypeMap)",
 				rb_obj_classname( type_map ) );
 	}
@@ -136,10 +136,6 @@ pg_copycoder_type_map_set(VALUE self, VALUE type_map)
  * call-seq:
  *    coder.type_map -> PG::TypeMap
  *
- * Returns either:
- * * a kind of PG::TypeMap
- * * +nil+ - use String coder only.
- *
  */
 static VALUE
 pg_copycoder_type_map_get(VALUE self)
@@ -169,22 +165,14 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 {
 	t_pg_copycoder *this = (t_pg_copycoder *)conv;
 	t_pg_coder_enc_func enc_func;
-	VALUE typemap;
 	static t_pg_coder *p_elem_coder;
 	int i;
 	t_typemap *p_typemap;
 	char *current_out;
 	char *end_capa_ptr;
 
-	if( NIL_P(this->typemap) ){
-		Data_Get_Struct( pg_default_typemap, t_typemap, p_typemap);
-		/* We don't need to call fit_to_query for pg_default_typemap. It does nothing. */
-		typemap = pg_default_typemap;
-	} else {
-		p_typemap = DATA_PTR( this->typemap );
-		typemap = p_typemap->fit_to_query( this->typemap, value );
-		p_typemap = DATA_PTR( typemap );
-	}
+	p_typemap = DATA_PTR( this->typemap );
+	p_typemap->funcs.fit_to_query( this->typemap, value );
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
 	PG_RB_STR_NEW( *intermediate, current_out, end_capa_ptr );
@@ -211,7 +199,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 				current_out += RSTRING_LEN(this->null_string);
 				break;
 			default:
-				p_elem_coder = p_typemap->typecast_query_param(typemap, entry, i);
+				p_elem_coder = p_typemap->funcs.typecast_query_param(p_typemap, entry, i);
 				enc_func = pg_coder_enc_func(p_elem_coder);
 
 				/* 1st pass for retiving the required memory space */
@@ -337,12 +325,8 @@ pg_text_dec_copy_row(t_pg_coder *conv, char *input_line, int len, int _tuple, in
 	char *end_capa_ptr;
 	t_typemap *p_typemap;
 
-	if( NIL_P(this->typemap) ){
-		Data_Get_Struct( pg_default_typemap, t_typemap, p_typemap);
-	} else {
-		p_typemap = DATA_PTR( this->typemap );
-	}
-	expected_fields = p_typemap->fit_to_copy_get( this->typemap );
+	p_typemap = DATA_PTR( this->typemap );
+	expected_fields = p_typemap->funcs.fit_to_copy_get( this->typemap );
 
 	/* The received input string will probably have this->nfields fields. */
 	array = rb_ary_new2(expected_fields);
@@ -504,7 +488,7 @@ pg_text_dec_copy_row(t_pg_coder *conv, char *input_line, int len, int _tuple, in
 			VALUE field_value;
 
 			rb_str_set_len( field_str, output_ptr - RSTRING_PTR(field_str) );
-			field_value = p_typemap->typecast_copy_get( p_typemap, field_str, fieldno, 0, enc_idx );
+			field_value = p_typemap->funcs.typecast_copy_get( p_typemap, field_str, fieldno, 0, enc_idx );
 
 			rb_ary_push(array, field_value);
 

data/ext/pg_errors.c

@@ -10,6 +10,9 @@ VALUE rb_ePGerror;
 VALUE rb_eServerError;
 VALUE rb_eUnableToSend;
 VALUE rb_eConnectionBad;
+VALUE rb_eInvalidResultStatus;
+VALUE rb_eNoResultError;
+VALUE rb_eInvalidChangeOfResultFields;
 
 static VALUE
 define_error_class(const char *name, const char *baseclass_code)
@@ -84,6 +87,9 @@ init_pg_errors()
 	rb_eServerError = rb_define_class_under( rb_mPG, "ServerError", rb_ePGerror );
 	rb_eUnableToSend = rb_define_class_under( rb_mPG, "UnableToSend", rb_ePGerror );
 	rb_eConnectionBad = rb_define_class_under( rb_mPG, "ConnectionBad", rb_ePGerror );
+	rb_eInvalidResultStatus = rb_define_class_under( rb_mPG, "InvalidResultStatus", rb_ePGerror );
+	rb_eNoResultError = rb_define_class_under( rb_mPG, "NoResultError", rb_ePGerror );
+	rb_eInvalidChangeOfResultFields = rb_define_class_under( rb_mPG, "InvalidChangeOfResultFields", rb_ePGerror );
 
 	#include "errorcodes.def"
 }

data/ext/pg_result.c

@@ -27,28 +27,32 @@ static t_pg_result *pgresult_get_this_safe( VALUE );
 VALUE
 pg_new_result(PGresult *result, VALUE rb_pgconn)
 {
+	int nfields = result ? PQnfields(result) : 0;
 	VALUE self = pgresult_s_allocate( rb_cPGresult );
-	t_pg_result *this = pgresult_get_this(self);
-	t_pg_connection *p_conn = pg_get_connection(rb_pgconn);
+	t_pg_result *this;
 
-	PG_ENCODING_SET_NOCHECK(self, ENCODING_GET(rb_pgconn));
+	this = (t_pg_result *)xmalloc(sizeof(*this) +  sizeof(*this->fnames) * nfields);
+	DATA_PTR(self) = this;
 
 	this->pgresult = result;
 	this->connection = rb_pgconn;
-	if( result ){
-		VALUE typemap = p_conn->type_map_for_results;
+	this->typemap = pg_typemap_all_strings;
+	this->p_typemap = DATA_PTR( this->typemap );
+	this->autoclear = 0;
+	this->nfields = -1;
+	this->tuple_hash = Qnil;
 
-		if( !NIL_P(typemap) ){
-			t_typemap *p_typemap;
+	PG_ENCODING_SET_NOCHECK(self, ENCODING_GET(rb_pgconn));
 
-			/* Type check is done when assigned to PG::Connection. */
-			p_typemap = DATA_PTR(typemap);
+	if( result ){
+		t_pg_connection *p_conn = pg_get_connection(rb_pgconn);
+		VALUE typemap = p_conn->type_map_for_results;
 
-			typemap = p_typemap->fit_to_result( typemap, self );
-			this->p_typemap = DATA_PTR( typemap );
-		}
+		/* Type check is done when assigned to PG::Connection. */
+		t_typemap *p_typemap = DATA_PTR(typemap);
 
-		this->typemap = typemap;
+		this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
+		this->p_typemap = DATA_PTR( this->typemap );
 	}
 
 	return self;
@@ -74,11 +78,11 @@ pg_result_check( VALUE self )
 {
 	t_pg_result *this = pgresult_get_this(self);
 	VALUE error, exception, klass;
-	PGconn *conn = pg_get_pgconn(this->connection);
 	char * sqlstate;
 
 	if(this->pgresult == NULL)
 	{
+		PGconn *conn = pg_get_pgconn(this->connection);
 		error = rb_str_new2( PQerrorMessage(conn) );
 	}
 	else
@@ -162,7 +166,7 @@ pgresult_cleared_p( VALUE self )
 
 /*
  * call-seq:
- *    res.autoclose?      -> boolean
+ *    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.
@@ -185,8 +189,16 @@ pgresult_autoclear_p( VALUE self )
 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] );
+	}
 }
 
 /*
@@ -195,6 +207,7 @@ pgresult_gc_mark( t_pg_result *this )
 static void
 pgresult_gc_free( t_pg_result *this )
 {
+	if( !this ) return;
 	if(this->pgresult != NULL && !this->autoclear)
 		PQclear(this->pgresult);
 
@@ -216,6 +229,10 @@ pgresult_get_this_safe( VALUE self )
 
 /*
  * Fetch the PGresult pointer for the result object and check validity
+ *
+ * Note: This function is used externally by the sequel_pg gem,
+ * so do changes carefully.
+ *
  */
 PGresult*
 pgresult_get(VALUE self)
@@ -235,18 +252,30 @@ pgresult_get(VALUE self)
 static VALUE
 pgresult_s_allocate( VALUE klass )
 {
-	t_pg_result *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_result, pgresult_gc_mark, pgresult_gc_free, this );
-
-	this->pgresult = NULL;
-	this->connection = Qnil;
-	this->typemap = Qnil;
-	this->p_typemap = DATA_PTR( pg_default_typemap );
-	this->autoclear = 0;
+	VALUE self = Data_Wrap_Struct( klass, pgresult_gc_mark, pgresult_gc_free, NULL );
 
 	return self;
 }
 
+static void pgresult_init_fnames(VALUE self)
+{
+	t_pg_result *this = pgresult_get_this_safe(self);
+
+	if( this->nfields == -1 ){
+		int i;
+		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);
+			this->nfields = i + 1;
+
+			RB_GC_GUARD(fname);
+		}
+		this->nfields = nfields;
+	}
+}
 
 /********************************************************************
  *
@@ -395,6 +424,12 @@ pgresult_ntuples(VALUE self)
 	return INT2FIX(PQntuples(pgresult_get(self)));
 }
 
+static VALUE
+pgresult_ntuples_for_enum(VALUE self, VALUE args, VALUE eobj)
+{
+    return pgresult_ntuples(self);
+}
+
 /*
  * call-seq:
  *    res.nfields() -> Integer
@@ -417,16 +452,16 @@ static VALUE
 pgresult_fname(VALUE self, VALUE index)
 {
 	VALUE fname;
-	PGresult *result;
+	PGresult *result = pgresult_get(self);
 	int i = NUM2INT(index);
 
-	result = pgresult_get(self);
 	if (i < 0 || i >= PQnfields(result)) {
 		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 fname;
+	return rb_obj_freeze(fname);
 }
 
 /*
@@ -633,7 +668,7 @@ pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
 	if(j < 0 || j >= PQnfields(this->pgresult)) {
 		rb_raise(rb_eArgError,"invalid field number %d", j);
 	}
-	return this->p_typemap->typecast_result_value(self, i, j);
+	return this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, i, j);
 }
 
 /*
@@ -783,18 +818,26 @@ pgresult_aref(VALUE self, VALUE index)
 	t_pg_result *this = pgresult_get_this_safe(self);
 	int tuple_num = NUM2INT(index);
 	int field_num;
-	VALUE fname;
+	int num_tuples = PQntuples(this->pgresult);
 	VALUE tuple;
 
-	if ( tuple_num < 0 || tuple_num >= PQntuples(this->pgresult) )
+	if( this->nfields == -1 )
+		pgresult_init_fnames( self );
+
+	if ( tuple_num < 0 || tuple_num >= num_tuples )
 		rb_raise( rb_eIndexError, "Index %d is out of range", tuple_num );
 
-	tuple = rb_hash_new();
-	for ( field_num = 0; field_num < PQnfields(this->pgresult); field_num++ ) {
-		fname = rb_tainted_str_new2( PQfname(this->pgresult,field_num) );
-		PG_ENCODING_SET_NOCHECK(fname, ENCODING_GET(self));
-		rb_hash_aset( tuple, fname, this->p_typemap->typecast_result_value(self, tuple_num, field_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;
+	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 )
+		this->tuple_hash = rb_hash_dup(tuple);
+
 	return tuple;
 }
 
@@ -807,20 +850,26 @@ pgresult_aref(VALUE self, VALUE index)
 static VALUE
 pgresult_each_row(VALUE self)
 {
-	t_pg_result *this = pgresult_get_this_safe(self);
+	t_pg_result *this;
 	int row;
 	int field;
-	int num_rows = PQntuples(this->pgresult);
-	int num_fields = PQnfields(this->pgresult);
+	int num_rows;
+	int num_fields;
+
+	RETURN_SIZED_ENUMERATOR(self, 0, NULL, pgresult_ntuples_for_enum);
+
+	this = pgresult_get_this_safe(self);
+	num_rows = PQntuples(this->pgresult);
+	num_fields = PQnfields(this->pgresult);
 
 	for ( row = 0; row < num_rows; row++ ) {
-		VALUE new_row = rb_ary_new2(num_fields);
+		VALUE row_values[num_fields];
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
-			rb_ary_store( new_row, field, this->p_typemap->typecast_result_value(self, row, field) );
+			row_values[field] = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, row, field);
 		}
-		rb_yield( new_row );
+		rb_yield( rb_ary_new4( num_fields, row_values ));
 	}
 
 	return Qnil;
@@ -843,13 +892,13 @@ pgresult_values(VALUE self)
 	VALUE results = rb_ary_new2( num_rows );
 
 	for ( row = 0; row < num_rows; row++ ) {
-		VALUE new_row = rb_ary_new2(num_fields);
+		VALUE row_values[num_fields];
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
-			rb_ary_store( new_row, field, this->p_typemap->typecast_result_value(self, row, field) );
+			row_values[field] = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, row, field);
 		}
-		rb_ary_store( results, row, new_row );
+		rb_ary_store( results, row, rb_ary_new4( num_fields, row_values ) );
 	}
 
 	return results;
@@ -871,7 +920,7 @@ make_column_result_array( VALUE self, int col )
 		rb_raise( rb_eIndexError, "no column %d in result", col );
 
 	for ( i=0; i < rows; i++ ) {
-		VALUE val = this->p_typemap->typecast_result_value(self, i, col);
+		VALUE val = this->p_typemap->funcs.typecast_result_value(this->p_typemap, self, i, col);
 		rb_ary_store( results, i, val );
 	}
 
@@ -925,9 +974,13 @@ pgresult_field_values( VALUE self, VALUE field )
 static VALUE
 pgresult_each(VALUE self)
 {
-	PGresult *result = pgresult_get(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++) {
 		rb_yield(pgresult_aref(self, INT2NUM(tuple_num)));
 	}
@@ -943,18 +996,12 @@ pgresult_each(VALUE self)
 static VALUE
 pgresult_fields(VALUE self)
 {
-	PGresult *result = pgresult_get( self );
-	int n = PQnfields( result );
-	VALUE fields = rb_ary_new2( n );
-	int i;
+	t_pg_result *this = pgresult_get_this_safe(self);
 
-	for ( i = 0; i < n; i++ ) {
-		VALUE val = rb_tainted_str_new2(PQfname(result, i));
-		PG_ENCODING_SET_NOCHECK(val, ENCODING_GET(self));
-		rb_ary_store( fields, i, val );
-	}
+	if( this->nfields == -1 )
+		pgresult_init_fnames( self );
 
-	return fields;
+	return rb_ary_new4( this->nfields, this->fnames );
 }
 
 /*
@@ -967,32 +1014,23 @@ pgresult_fields(VALUE self)
  * type casts from PostgreSQL's wire format to Ruby objects on the fly,
  * according to the rules and decoders defined in the given typemap.
  *
- * +typemap+ can be:
- * * a kind of PG::TypeMap
- * * +nil+ - to type cast all result values to String.
+ * +typemap+ must be a kind of PG::TypeMap .
  *
  */
 static VALUE
 pgresult_type_map_set(VALUE self, VALUE typemap)
 {
 	t_pg_result *this = pgresult_get_this(self);
+	t_typemap *p_typemap;
 
-	if( NIL_P(typemap) ){
-		this->p_typemap = DATA_PTR( pg_default_typemap );
-	} else {
-		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);
-
-		typemap = p_typemap->fit_to_result( typemap, self );
-		this->p_typemap = DATA_PTR( 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);
 
-	this->typemap = typemap;
+	this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
+	this->p_typemap = DATA_PTR( this->typemap );
 
 	return typemap;
 }
@@ -1003,10 +1041,6 @@ pgresult_type_map_set(VALUE self, VALUE typemap)
  *
  * Returns the TypeMap that is currently set for type casts of result values to ruby objects.
  *
- * Returns either:
- * * a kind of PG::TypeMap or
- * * +nil+ - when no type map is set.
- *
  */
 static VALUE
 pgresult_type_map_get(VALUE self)
@@ -1016,6 +1050,162 @@ pgresult_type_map_get(VALUE self)
 	return this->typemap;
 }
 
+#ifdef HAVE_PQSETSINGLEROWMODE
+/*
+ * 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)
+ */
+static VALUE
+pgresult_stream_each(VALUE self)
+{
+	t_pg_result *this;
+	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 tuple_num;
+		int ntuples = PQntuples(pgresult);
+
+		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 );
+		}
+
+		for(tuple_num = 0; tuple_num < ntuples; tuple_num++) {
+			rb_yield(pgresult_aref(self, INT2NUM(tuple_num)));
+		}
+
+		if( !this->autoclear ){
+			PQclear( pgresult );
+			this->pgresult = NULL;
+		}
+
+		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");
+
+		this->pgresult = pgresult;
+	}
+
+	/* never reached */
+	return self;
+}
+
+/*
+ * call-seq:
+ *    res.stream_each_row { |row| ... }
+ *
+ * Yields each row of the result set in single row mode.
+ * The row is a list of column values.
+ *
+ * This method works equally to #stream_each , but yields an Array of
+ * values.
+ */
+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);
+
+		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 );
+		}
+
+		for ( row = 0; row < ntuples; row++ ) {
+			VALUE row_values[nfields];
+			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 ));
+		}
+
+		if( !this->autoclear ){
+			PQclear( pgresult );
+			this->pgresult = NULL;
+		}
+
+		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");
+
+		this->pgresult = pgresult;
+	}
+
+	/* never reached */
+	return self;
+}
+#endif
+
 
 void
 init_pg_result()
@@ -1070,6 +1260,12 @@ init_pg_result()
 
 	rb_define_method(rb_cPGresult, "type_map=", pgresult_type_map_set, 1);
 	rb_define_method(rb_cPGresult, "type_map", pgresult_type_map_get, 0);
+
+#ifdef HAVE_PQSETSINGLEROWMODE
+	/******     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);
+#endif
 }