pg 0.14.1 → 0.15.0.pre.432

data/History.rdoc

@@ -1,3 +1,38 @@
+== v0.15.0 [YYYY-MM-DD] Michael Granger <ged@FaerieMUD.org>
+
+Bugfixes:
+
+- Fix segfault in PG::Result#field_values when called with non String value.
+- Fix encoding of messages delivered by notice callbacks.
+- Fix text encoding for Connection#wait_for_notify and Connection#notifies.
+- Fix 'Bad file descriptor' problems under Windows: wrong behaviour of
+  #wait_for_notify() and timeout handling of #block on Ruby 1.9.
+
+Documentation fixes:
+
+- conn#socket() can not be used with IO.for_fd() on Windows.
+
+Enhancements:
+
+- Add single row mode of PostgreSQL 9.2.
+- Set fallback_application_name to programm name $0. Thanks to Will Leinweber
+  for the patch.
+- Release Ruby's GVL while calls to blocking libpq functions to allow better
+  concurrency in threaded applications.
+- Refactor different variants of waiting for the connection socket.
+- Make use of rb_thread_fd_select() on Ruby 1.9 and avoid deprecated
+  rb_thread_select().
+- Add an example of how to insert array data using a prepared statement (#145).
+- Add continous integration tests on travis-ci.org.
+- Add PG::Result#each_value for looping over result sets by row. Thanks to
+  Aaron Patterson for the patch.
+
+Specs:
+
+- Fix various specs to run on older PostgreSQL and Ruby versions.
+- Avoid fork() in specs to allow usage on Windows and JRuby.
+
+
 == v0.14.1 [2012-09-02] Michael Granger <ged@FaerieMUD.org>
 
 Important bugfix:

data/Manifest.txt

@@ -13,6 +13,8 @@ README.rdoc
 Rakefile
 Rakefile.cross
 ext/extconf.rb
+ext/gvl_wrappers.c
+ext/gvl_wrappers.h
 ext/pg.c
 ext/pg.h
 ext/pg_connection.c
@@ -25,6 +27,7 @@ lib/pg/connection.rb
 lib/pg/constants.rb
 lib/pg/exceptions.rb
 lib/pg/result.rb
+sample/array_insert.rb
 sample/async_api.rb
 sample/async_copyto.rb
 sample/async_mixed.rb

data/README.rdoc

@@ -1,3 +1,5 @@
+{<img src="https://travis-ci.org/ged/ruby-pg.png?branch=master" alt="Build Status" />}[https://travis-ci.org/ged/ruby-pg]
+
 = pg
 
 * https://bitbucket.org/ged/ruby-pg
@@ -11,14 +13,14 @@ It works with {PostgreSQL 8.3 and later}[http://bit.ly/6AfPhm].
 A small example usage:
 
   #!/usr/bin/env ruby
-  
+
   require 'pg'
-  
+
   # Output a table of current connections to the DB
   conn = PG.connect( dbname: 'sales' )
   conn.exec( "SELECT * FROM pg_stat_activity" ) do |result|
     puts "     PID | User             | Query"
-	result.each do |row|
+  result.each do |row|
       puts " %7d | %-16s | %s " %
         row.values_at('procpid', 'usename', 'current_query')
     end

data/Rakefile.cross

@@ -19,7 +19,7 @@ end
 
 # Cross-compilation constants
 OPENSSL_VERSION            = ENV['OPENSSL_VERSION'] || '1.0.1c'
-POSTGRESQL_VERSION         = ENV['POSTGRESQL_VERSION'] || '9.1.4'
+POSTGRESQL_VERSION         = ENV['POSTGRESQL_VERSION'] || '9.2.2'
 
 COMPILE_HOME               = Pathname( "./build" ).expand_path
 STATIC_SOURCESDIR          = COMPILE_HOME + 'sources'
@@ -172,7 +172,7 @@ file STATIC_POSTGRESQL_BUILDDIR => POSTGRESQL_TARBALL do |t|
 	STATIC_POSTGRESQL_BUILDDIR.mkpath
 	run 'tar', '-xjf', POSTGRESQL_TARBALL.to_s, '-C', STATIC_POSTGRESQL_BUILDDIR.parent.to_s
 	mv POSTGRESQL_SHLIB_MAKEFILE, POSTGRESQL_SHLIB_MF_ORIG
-	
+
 	POSTGRESQL_PATCHES.each do |patchfile|
 		puts "  applying patch #{patchfile}..."
 		run 'patch', '-Np1', '-d', STATIC_POSTGRESQL_BUILDDIR.to_s,

data/ext/extconf.rb

@@ -32,7 +32,9 @@ dir_config 'pg'
 if pgconfig = ( with_config('pg-config') || with_config('pg_config') || find_executable('pg_config') )
 	$stderr.puts "Using config values from %s" % [ pgconfig ]
 	$CPPFLAGS << " -I%s" % [ `"#{pgconfig}" --includedir`.chomp ]
-	$LDFLAGS << " -L%s" % [ `"#{pgconfig}" --libdir`.chomp ]
+
+	libdir = `"#{pgconfig}" --libdir`.chomp
+	$LDFLAGS << " -L%s -Wl,-rpath,%s" % [ libdir, libdir ]
 else
 	$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
 		" --with-pg-config=/path/to/pg_config"
@@ -65,9 +67,13 @@ have_func 'pg_char_to_encoding'
 have_func 'PQsetClientEncoding'
 have_func 'PQlibVersion'
 have_func 'PQping'
+have_func 'PQsetSingleRowMode'
 
 have_func 'rb_encdb_alias'
 have_func 'rb_enc_alias'
+have_func 'rb_thread_call_without_gvl'
+have_func 'rb_thread_call_with_gvl'
+have_func 'rb_thread_fd_select'
 
 have_const 'PGRES_COPY_BOTH', 'libpq-fe.h'
 have_const 'PGRES_SINGLE_TUPLE', 'libpq-fe.h'

data/ext/gvl_wrappers.c

@@ -0,0 +1,13 @@
+/*
+ * gvl_wrappers.c - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ */
+
+#include "pg.h"
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_SKELETON );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_SKELETON );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_STUB );

data/ext/gvl_wrappers.h

@@ -0,0 +1,185 @@
+/*
+ * gvl_wrappers.h - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ * These are some obscure preprocessor directives that allow to generate
+ * drop-in replacement wrapper functions in a declarative manner.
+ * These wrapper functions ensure that ruby's GVL is released on each
+ * function call and reacquired at the end of the call or in callbacks.
+ * This way blocking functions calls don't block concurrent ruby threads.
+ *
+ * The wrapper of each function is prefixed by "gvl_".
+ *
+ * Use "gcc -E" to retrieve the generated code.
+ */
+
+#ifndef __gvl_wrappers_h
+#define __gvl_wrappers_h
+
+#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
+extern void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1);
+#endif
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
+				 rb_unblock_function_t *ubf, void *data2);
+#endif
+
+#define DEFINE_PARAM_LIST1(type, name) \
+	name,
+
+#define DEFINE_PARAM_LIST2(type, name) \
+	p->params.name,
+
+#define DEFINE_PARAM_LIST3(type, name) \
+	type name,
+
+#define DEFINE_PARAM_DECL(type, name) \
+	type name;
+
+#define DEFINE_GVL_WRAPPER_STRUCT(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	struct gvl_wrapper_##name##_params { \
+		struct { \
+			FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_DECL) \
+			lastparamtype lastparamname; \
+		} params; \
+		when_non_void( rettype retval; ) \
+	};
+
+#define DEFINE_GVL_SKELETON(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	static void * gvl_##name##_skeleton( void *data ){ \
+		struct gvl_wrapper_##name##_params *p = (struct gvl_wrapper_##name##_params*)data; \
+		when_non_void( p->retval = ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST2) p->params.lastparamname ); \
+		return NULL; \
+	}
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+	#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+		rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+			struct gvl_wrapper_##name##_params params = { \
+				{FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname}, when_non_void((rettype)0) \
+			}; \
+			rb_thread_call_without_gvl(gvl_##name##_skeleton, &params, RUBY_UBF_IO, 0); \
+			when_non_void( return params.retval; ) \
+		}
+#else
+	#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+		rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+			return name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
+		}
+#endif
+
+#define DEFINE_GVL_STUB_DECL(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname);
+
+#define DEFINE_GVLCB_SKELETON(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	static void * gvl_##name##_skeleton( void *data ){ \
+		struct gvl_wrapper_##name##_params *p = (struct gvl_wrapper_##name##_params*)data; \
+		when_non_void( p->retval = ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST2) p->params.lastparamname ); \
+		return NULL; \
+	}
+
+#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
+	#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+		rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+			struct gvl_wrapper_##name##_params params = { \
+				{FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname}, when_non_void((rettype)0) \
+			}; \
+			rb_thread_call_with_gvl(gvl_##name##_skeleton, &params); \
+			when_non_void( return params.retval; ) \
+		}
+#else
+	#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+		rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+			return name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
+		}
+#endif
+
+#define GVL_TYPE_VOID(string)
+#define GVL_TYPE_NONVOID(string) string
+
+
+/*
+ * Definitions of blocking functions and their parameters
+ */
+
+#define FOR_EACH_PARAM_OF_PQexec(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQexecParams(param) \
+	param(PGconn *, conn) \
+	param(const char *, command) \
+	param(int, nParams) \
+	param(const Oid *, paramTypes) \
+	param(const char * const *, paramValues) \
+	param(const int *, paramLengths) \
+	param(const int *, paramFormats)
+
+#define FOR_EACH_PARAM_OF_PQexecPrepared(param) \
+	param(PGconn *, conn) \
+	param(const char *, stmtName) \
+	param(int, nParams) \
+	param(const char * const *, paramValues) \
+	param(const int *, paramLengths) \
+	param(const int *, paramFormats)
+
+#define FOR_EACH_PARAM_OF_PQprepare(param) \
+	param(PGconn *, conn) \
+	param(const char *, stmtName) \
+	param(const char *, query) \
+	param(int, nParams)
+
+#define FOR_EACH_PARAM_OF_PQdescribePrepared(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQdescribePortal(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQgetResult(param)
+
+#define FOR_EACH_PARAM_OF_PQputCopyData(param) \
+	param(PGconn *, conn) \
+	param(const char *, buffer)
+
+#define FOR_EACH_PARAM_OF_PQputCopyEnd(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQgetCopyData(param) \
+	param(PGconn *, conn) \
+	param(char **, buffer)
+
+/* function( name, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
+#define FOR_EACH_BLOCKING_FUNCTION(function) \
+	function(PQexec, GVL_TYPE_NONVOID, PGresult *, const char *, command) \
+	function(PQexecParams, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
+	function(PQexecPrepared, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
+	function(PQprepare, GVL_TYPE_NONVOID, PGresult *, const Oid *, paramTypes) \
+	function(PQdescribePrepared, GVL_TYPE_NONVOID, PGresult *, const char *, stmtName) \
+	function(PQdescribePortal, GVL_TYPE_NONVOID, PGresult *, const char *, portalName) \
+	function(PQgetResult, GVL_TYPE_NONVOID, PGresult *, PGconn *, conn) \
+	function(PQputCopyData, GVL_TYPE_NONVOID, int, int, nbytes) \
+	function(PQputCopyEnd, GVL_TYPE_NONVOID, int, const char *, errormsg) \
+	function(PQgetCopyData, GVL_TYPE_NONVOID, int, int, async) \
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
+
+
+/*
+ * Definitions of callback functions and their parameters
+ */
+
+#define FOR_EACH_PARAM_OF_notice_processor_proxy(param) \
+	param(void *, arg)
+
+#define FOR_EACH_PARAM_OF_notice_receiver_proxy(param) \
+	param(void *, arg)
+
+/* function( name, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
+#define FOR_EACH_CALLBACK_FUNCTION(function) \
+	function(notice_processor_proxy, GVL_TYPE_VOID, void, const char *, message) \
+	function(notice_receiver_proxy, GVL_TYPE_VOID, void, const PGresult *, result) \
+
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVL_STUB_DECL );
+
+#endif /* end __gvl_wrappers_h */

data/ext/pg.c

@@ -1,6 +1,6 @@
 /*
  * pg.c - Toplevel extension
- * $Id: pg.c,v a965926418dd 2012/05/07 15:01:03 ged $
+ * $Id: pg.c,v d0c5d5f7f1e8 2012/12/26 21:09:28 kanis $
  *
  * Author/s:
  *
@@ -129,7 +129,7 @@ static ID s_id_index;
 
 /*
  * Get the index of encoding +val+.
- * :FIXME: Look into replacing this with rb_enc_get_index() since 1.9.1 isn't really 
+ * :FIXME: Look into replacing this with rb_enc_get_index() since 1.9.1 isn't really
  * used anymore.
  */
 int
@@ -174,7 +174,7 @@ pg_find_or_create_johab(void)
  * - returns ASCII-8BIT if the client encoding is unknown.
  */
 rb_encoding *
-pg_get_pg_encoding_as_rb_encoding( int enc_id ) 
+pg_get_pg_encoding_as_rb_encoding( int enc_id )
 {
 	rb_encoding *enc;
 
@@ -409,7 +409,7 @@ Init_pg_ext()
 	rb_define_const(rb_mPGconstants, "PGRES_EMPTY_QUERY", INT2FIX(PGRES_EMPTY_QUERY));
 	/* #result_status constant: Successful completion of a command returning no data. */
 	rb_define_const(rb_mPGconstants, "PGRES_COMMAND_OK", INT2FIX(PGRES_COMMAND_OK));
-		/* #result_status constant: Successful completion of a command returning data 
+		/* #result_status constant: Successful completion of a command returning data
 	   (such as a SELECT or SHOW). */
 	rb_define_const(rb_mPGconstants, "PGRES_TUPLES_OK", INT2FIX(PGRES_TUPLES_OK));
 	/* #result_status constant: Copy Out (from server) data transfer started. */
@@ -426,6 +426,10 @@ Init_pg_ext()
 #ifdef HAVE_CONST_PGRES_COPY_BOTH
 	rb_define_const(rb_mPGconstants, "PGRES_COPY_BOTH", INT2FIX(PGRES_COPY_BOTH));
 #endif
+	/* #result_status constant: Single tuple from larger resultset. */
+#ifdef HAVE_CONST_PGRES_SINGLE_TUPLE
+	rb_define_const(rb_mPGconstants, "PGRES_SINGLE_TUPLE", INT2FIX(PGRES_SINGLE_TUPLE));
+#endif
 
 	/******     Result CONSTANTS: result error field codes      ******/
 
@@ -509,7 +513,7 @@ Init_pg_ext()
 	/* Add the constants to the toplevel namespace */
 	rb_include_module( rb_mPG, rb_mPGconstants );
 
-#ifdef M17N_SUPPORTED	
+#ifdef M17N_SUPPORTED
 	enc_pg2ruby = st_init_numtable();
 	s_id_index = rb_intern("@encoding");
 #endif

data/ext/pg.h

@@ -77,6 +77,7 @@ __declspec(dllexport)
 typedef long suseconds_t;
 #endif
 
+#include "gvl_wrappers.h"
 
 /***************************************************************************
  * Globals
@@ -119,5 +120,7 @@ int pg_enc_get_index                                   _(( VALUE ));
 rb_encoding *pg_conn_enc_get                           _(( PGconn * ));
 #endif /* M17N_SUPPORTED */
 
+void notice_receiver_proxy(void *arg, const PGresult *result);
+void notice_processor_proxy(void *arg, const char *message);
 
 #endif /* end __pg_h */

data/ext/pg_connection.c

@@ -1,6 +1,6 @@
 /*
  * pg_connection.c - PG::Connection class extension
- * $Id: pg_connection.c,v de900bfaff1a 2012/07/03 14:38:38 kanis $
+ * $Id: pg_connection.c,v 7c313c2355b7 2013/02/03 18:37:06 ged $
  *
  */
 
@@ -8,10 +8,10 @@
 
 
 /********************************************************************
- * 
+ *
  * Document-class: PG::Connection
  *
- * The class to access PostgreSQL RDBMS, based on the libpq interface, 
+ * The class to access PostgreSQL RDBMS, based on the libpq interface,
  * provides convenient OO methods to interact with PostgreSQL.
  *
  * For example, to send query to the database on the localhost:
@@ -35,6 +35,15 @@ static VALUE pgconn_finish( VALUE );
 static VALUE pgconn_set_default_encoding( VALUE self );
 #endif
 
+#ifndef HAVE_RB_THREAD_FD_SELECT
+#define rb_fdset_t fd_set
+#define rb_fd_init(f)
+#define rb_fd_zero(f)  FD_ZERO(f)
+#define rb_fd_set(n, f)  FD_SET(n, f)
+#define rb_fd_term(f)
+#define rb_thread_fd_select rb_thread_select
+#endif
+
 /*
  * Global functions
  */
@@ -92,7 +101,7 @@ pgconn_gc_free( PGconn *conn )
 
 /*
  * Document-method: allocate
- * 
+ *
  * call-seq:
  *   PG::Connection.allocate -> conn
  */
@@ -111,9 +120,9 @@ pgconn_s_allocate( VALUE klass )
  *    PG::Connection.new(connection_hash) -> conn
  *    PG::Connection.new(connection_string) -> conn
  *    PG::Connection.new(host, port, options, tty, dbname, user, password) ->  conn
- * 
+ *
  * Create a connection to the specified server.
- * 
+ *
  * [+host+]
  *   server hostname
  * [+hostaddr+]
@@ -140,24 +149,24 @@ pgconn_s_allocate( VALUE klass )
  *   GSS library to use for GSSAPI authentication
  * [+service+]
  *   service name to use for additional parameters
- * 
+ *
  * Examples:
- * 
+ *
  *   # Connect using all defaults
  *   PG::Connection.new
  *
  *   # As a Hash
  *   PG::Connection.new( :dbname => 'test', :port => 5432 )
- *   
+ *
  *   # As a String
  *   PG::Connection.new( "dbname=test port=5432" )
- *   
+ *
  *   # As an Array
  *   PG::Connection.new( nil, 5432, nil, nil, 'test', nil, nil )
- *  
+ *
  * If the Ruby default internal encoding is set (i.e., Encoding.default_internal != nil), the
  * connection will have its +client_encoding+ set accordingly.
- * 
+ *
  * Raises a PG::Error if the connection fails.
  */
 static VALUE
@@ -202,11 +211,11 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
  *
  * Use #connect_poll to poll the status of the connection.
  *
- * NOTE: this does *not* set the connection's +client_encoding+ for you if 
- * Encoding.default_internal is set. To set it after the connection is established, 
- * call #internal_encoding=. You can also set it automatically by setting 
+ * NOTE: this does *not* set the connection's +client_encoding+ for you if
+ * Encoding.default_internal is set. To set it after the connection is established,
+ * call #internal_encoding=. You can also set it automatically by setting
  * ENV['PGCLIENTENCODING'], or include the 'options' connection parameter.
- * 
+ *
  */
 static VALUE
 pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
@@ -266,7 +275,6 @@ pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
 {
 	PGPing ping;
 	VALUE conninfo;
-	VALUE error;
 
 	conninfo = rb_funcall2( klass, rb_intern("parse_connect_args"), argc, argv );
 	ping     = PQping( StringValuePtr(conninfo) );
@@ -333,7 +341,7 @@ pgconn_s_conndefaults(VALUE self)
  *
  * This function is intended to be used by client applications that
  * send commands like: +ALTER USER joe PASSWORD 'pwd'+.
- * The arguments are the cleartext password, and the SQL name 
+ * The arguments are the cleartext password, and the SQL name
  * of the user it is for.
  *
  * Return value is the encrypted password.
@@ -439,7 +447,7 @@ pgconn_finished_p( VALUE self )
  * call-seq:
  *    conn.reset()
  *
- * Resets the backend connection. This method closes the 
+ * Resets the backend connection. This method closes the
  * backend connection and tries to re-connect.
  */
 static VALUE
@@ -456,7 +464,7 @@ pgconn_reset(VALUE self)
  * Initiate a connection reset in a nonblocking manner.
  * This will close the current connection and attempt to
  * reconnect using the same connection parameters.
- * Use #reset_poll to check the status of the 
+ * Use #reset_poll to check the status of the
  * connection reset.
  */
 static VALUE
@@ -617,14 +625,14 @@ pgconn_transaction_status(VALUE self)
  * _param_name_ is one of
  * * +server_version+
  * * +server_encoding+
- * * +client_encoding+ 
+ * * +client_encoding+
  * * +is_superuser+
  * * +session_authorization+
  * * +DateStyle+
  * * +TimeZone+
  * * +integer_datetimes+
  * * +standard_conforming_strings+
- * 
+ *
  * Returns nil if the value of the parameter is not known.
  */
 static VALUE
@@ -641,8 +649,8 @@ pgconn_parameter_status(VALUE self, VALUE param_name)
  * call-seq:
  *   conn.protocol_version -> Integer
  *
- * The 3.0 protocol will normally be used when communicating with PostgreSQL 7.4 
- * or later servers; pre-7.4 servers support only protocol 2.0. (Protocol 1.0 is 
+ * The 3.0 protocol will normally be used when communicating with PostgreSQL 7.4
+ * or later servers; pre-7.4 servers support only protocol 2.0. (Protocol 1.0 is
  * obsolete and not supported by libpq.)
  */
 static VALUE
@@ -651,16 +659,16 @@ pgconn_protocol_version(VALUE self)
 	return INT2NUM(PQprotocolVersion(pg_get_pgconn(self)));
 }
 
-/* 
- * call-seq: 
+/*
+ * call-seq:
  *   conn.server_version -> Integer
- * 
+ *
  * The number is formed by converting the major, minor, and revision
  * numbers into two-decimal-digit numbers and appending them together.
  * For example, version 7.4.2 will be returned as 70402, and version
  * 8.1 will be returned as 80100 (leading zeroes are not shown). Zero
  * is returned if the connection is bad.
- * 
+ *
  */
 static VALUE
 pgconn_server_version(VALUE self)
@@ -687,6 +695,15 @@ pgconn_error_message(VALUE self)
  *    conn.socket() -> Fixnum
  *
  * Returns the socket's file descriptor for this connection.
+ * <tt>IO.for_fd()</tt> can be used to build a proper IO object to the socket.
+ * If you do so, you will likely also want to set <tt>autoclose=false</tt>
+ * on it to prevent Ruby from closing the socket to PostgreSQL if it
+ * goes out of scope. Alternatively, you can use #socket_io, which
+ * creates an IO that's associated with the connection object itself,
+ * and so won't go out of scope until the connection does.
+ *
+ * *Note:* On Windows the file descriptor is not really usable,
+ * since it can not be used to build a Ruby IO object.
  */
 static VALUE
 pgconn_socket(VALUE self)
@@ -742,16 +759,64 @@ pgconn_connection_used_password(VALUE self)
 /* :TODO: get_ssl */
 
 
+static VALUE pgconn_exec_params( int, VALUE *, VALUE );
+
 /*
  * call-seq:
- *    conn.exec(sql [, params, result_format ] ) -> PG::Result
- *    conn.exec(sql [, params, result_format ] ) {|pg_result| block }
+ *    conn.exec(sql) -> PG::Result
+ *    conn.exec(sql) {|pg_result| block }
  *
  * Sends SQL query request specified by _sql_ to PostgreSQL.
  * Returns a PG::Result instance on success.
  * On failure, it raises a PG::Error.
  *
- * +params+ is an optional array of the bind parameters for the SQL query.
+ * For backward compatibility, if you pass more than one parameter to this method,
+ * it will call #exec_params for you. New code should explicitly use #exec_params if
+ * argument placeholders are used.
+ *
+ * If the optional code block is given, it will be passed <i>result</i> as an argument,
+ * and the PG::Result object will  automatically be cleared when the block terminates.
+ * In this instance, <code>conn.exec</code> returns the value of the block.
+ */
+static VALUE
+pgconn_exec(int argc, VALUE *argv, VALUE self)
+{
+	PGconn *conn = pg_get_pgconn(self);
+	PGresult *result = NULL;
+	VALUE rb_pgresult;
+
+	/* If called with no parameters, use PQexec */
+	if ( argc == 1 ) {
+		Check_Type(argv[0], T_STRING);
+
+		result = gvl_PQexec(conn, StringValuePtr(argv[0]));
+		rb_pgresult = pg_new_result(result, self);
+		pg_result_check(rb_pgresult);
+		if (rb_block_given_p()) {
+			return rb_ensure(rb_yield, rb_pgresult, pg_result_clear, rb_pgresult);
+		}
+		return rb_pgresult;
+	}
+	
+	/* Otherwise, just call #exec_params instead for backward-compatibility */
+	else {
+		return pgconn_exec_params( argc, argv, self );
+	}
+
+}
+
+
+/*
+ * call-seq:
+ *    conn.exec_params(sql, params[, result_format ] ) -> PG::Result
+ *    conn.exec_params(sql, params[, result_format ] ) {|pg_result| block }
+ *
+ * Sends SQL query request specified by +sql+ to PostgreSQL using placeholders
+ * for parameters.
+ *
+ * Returns a PG::Result instance on success. On failure, it raises a PG::Error.
+ *
+ * +params+ is an array of the bind parameters for the SQL query.
  * Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
@@ -760,11 +825,11 @@ pgconn_connection_used_password(VALUE self)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :type => 0, :format => 0 }
- * 
+ *
  * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
- * 
+ *
  * If the types are not specified, they will be inferred by PostgreSQL.
  * Instead of specifying type oids, it's recommended to simply add
  * explicit casts in the query to ensure that the right type is used.
@@ -774,12 +839,12 @@ pgconn_connection_used_password(VALUE self)
  * The optional +result_format+ should be 0 for text results, 1
  * for binary.
  *
- * If the optional code block is given, it will be passed <i>result</i> as an argument, 
- * and the PG::Result object will  automatically be cleared when the block terminates. 
+ * If the optional code block is given, it will be passed <i>result</i> as an argument,
+ * and the PG::Result object will  automatically be cleared when the block terminates.
  * In this instance, <code>conn.exec</code> returns the value of the block.
  */
 static VALUE
-pgconn_exec(int argc, VALUE *argv, VALUE self)
+pgconn_exec_params( int argc, VALUE *argv, VALUE self )
 {
 	PGconn *conn = pg_get_pgconn(self);
 	PGresult *result = NULL;
@@ -799,25 +864,17 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 
 	rb_scan_args(argc, argv, "12", &command, &params, &in_res_fmt);
 
-	Check_Type(command, T_STRING);
-
-	/* If called with no parameters, use PQexec */
-	if(NIL_P(params)) {
-		result = PQexec(conn, StringValuePtr(command));
-		rb_pgresult = pg_new_result(result, self);
-		pg_result_check(rb_pgresult);
-		if (rb_block_given_p()) {
-			return rb_ensure(rb_yield, rb_pgresult, pg_result_clear, rb_pgresult);
+	/*
+	 * Handle the edge-case where the caller is coming from #exec, but passed an explict +nil+
+	 * for the second parameter.
+	 */
+	if ( NIL_P(params) ) {
+		return pgconn_exec( 1, argv, self );
 		}
-		return rb_pgresult;
-	}
 
-	/* If called with parameters, and optionally result_format,
-	 * use PQexecParams
-	 */
 	Check_Type(params, T_ARRAY);
 
-	if(NIL_P(in_res_fmt)) {
+	if ( NIL_P(in_res_fmt) ) {
 		resultFormat = 0;
 	}
 	else {
@@ -826,15 +883,17 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 
 	gc_array = rb_ary_new();
 	rb_gc_register_address(&gc_array);
+
 	sym_type = ID2SYM(rb_intern("type"));
 	sym_value = ID2SYM(rb_intern("value"));
 	sym_format = ID2SYM(rb_intern("format"));
 	nParams = (int)RARRAY_LEN(params);
-	paramTypes = ALLOC_N(Oid, nParams); 
+	paramTypes = ALLOC_N(Oid, nParams);
 	paramValues = ALLOC_N(char *, nParams);
 	paramLengths = ALLOC_N(int, nParams);
 	paramFormats = ALLOC_N(int, nParams);
-	for(i = 0; i < nParams; i++) {
+
+	for ( i = 0; i < nParams; i++ ) {
 		param = rb_ary_entry(params, i);
 		if (TYPE(param) == T_HASH) {
 			param_type = rb_hash_aref(param, sym_type);
@@ -877,7 +936,7 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 			paramFormats[i] = NUM2INT(param_format);
 	}
 
-	result = PQexecParams(conn, StringValuePtr(command), nParams, paramTypes, 
+	result = gvl_PQexecParams(conn, StringValuePtr(command), nParams, paramTypes,
 		(const char * const *)paramValues, paramLengths, paramFormats, resultFormat);
 
 	rb_gc_unregister_address(&gc_array);
@@ -889,10 +948,11 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 
 	rb_pgresult = pg_new_result(result, self);
 	pg_result_check(rb_pgresult);
+
 	if (rb_block_given_p()) {
-		return rb_ensure(rb_yield, rb_pgresult, 
-			pg_result_clear, rb_pgresult);
+		return rb_ensure(rb_yield, rb_pgresult, pg_result_clear, rb_pgresult);
 	}
+
 	return rb_pgresult;
 }
 
@@ -904,7 +964,7 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
  * Returns a PG::Result instance on success.
  * On failure, it raises a PG::Error.
  *
- * +param_types+ is an optional parameter to specify the Oids of the 
+ * +param_types+ is an optional parameter to specify the Oids of the
  * types of the parameters.
  *
  * If the types are not specified, they will be inferred by PostgreSQL.
@@ -912,7 +972,7 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
  * explicit casts in the query to ensure that the right type is used.
  *
  * For example: "SELECT $1::int"
- * 
+ *
  * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
  * inside the SQL query.
  */
@@ -935,7 +995,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 	if(! NIL_P(in_paramtypes)) {
 		Check_Type(in_paramtypes, T_ARRAY);
 		nParams = (int)RARRAY_LEN(in_paramtypes);
-		paramTypes = ALLOC_N(Oid, nParams); 
+		paramTypes = ALLOC_N(Oid, nParams);
 		for(i = 0; i < nParams; i++) {
 			param = rb_ary_entry(in_paramtypes, i);
 			Check_Type(param, T_FIXNUM);
@@ -945,7 +1005,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 				paramTypes[i] = NUM2INT(param);
 		}
 	}
-	result = PQprepare(conn, StringValuePtr(name), StringValuePtr(command),
+	result = gvl_PQprepare(conn, StringValuePtr(name), StringValuePtr(command),
 			nParams, paramTypes);
 
 	xfree(paramTypes);
@@ -964,7 +1024,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  * Returns a PG::Result instance on success.
  * On failure, it raises a PG::Error.
  *
- * +params+ is an array of the optional bind parameters for the 
+ * +params+ is an array of the optional bind parameters for the
  * SQL query. Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
@@ -972,7 +1032,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :format => 0 }
- * 
+ *
  * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
@@ -980,8 +1040,8 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  * The optional +result_format+ should be 0 for text results, 1
  * for binary.
  *
- * If the optional code block is given, it will be passed <i>result</i> as an argument, 
- * and the PG::Result object will  automatically be cleared when the block terminates. 
+ * If the optional code block is given, it will be passed <i>result</i> as an argument,
+ * and the PG::Result object will  automatically be cleared when the block terminates.
  * In this instance, <code>conn.exec_prepared</code> returns the value of the block.
  */
 static VALUE
@@ -1064,8 +1124,8 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 			paramFormats[i] = NUM2INT(param_format);
 	}
 
-	result = PQexecPrepared(conn, StringValuePtr(name), nParams, 
-		(const char * const *)paramValues, paramLengths, paramFormats, 
+	result = gvl_PQexecPrepared(conn, StringValuePtr(name), nParams,
+		(const char * const *)paramValues, paramLengths, paramFormats,
 		resultFormat);
 
 	rb_gc_unregister_address(&gc_array);
@@ -1077,7 +1137,7 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 	rb_pgresult = pg_new_result(result, self);
 	pg_result_check(rb_pgresult);
 	if (rb_block_given_p()) {
-		return rb_ensure(rb_yield, rb_pgresult, 
+		return rb_ensure(rb_yield, rb_pgresult,
 			pg_result_clear, rb_pgresult);
 	}
 	return rb_pgresult;
@@ -1104,7 +1164,7 @@ pgconn_describe_prepared(VALUE self, VALUE stmt_name)
 		Check_Type(stmt_name, T_STRING);
 		stmt = StringValuePtr(stmt_name);
 	}
-	result = PQdescribePrepared(conn, stmt);
+	result = gvl_PQdescribePrepared(conn, stmt);
 	rb_pgresult = pg_new_result(result, self);
 	pg_result_check(rb_pgresult);
 	return rb_pgresult;
@@ -1132,7 +1192,7 @@ pgconn_describe_portal(self, stmt_name)
 		Check_Type(stmt_name, T_STRING);
 		stmt = StringValuePtr(stmt_name);
 	}
-	result = PQdescribePortal(conn, stmt);
+	result = gvl_PQdescribePortal(conn, stmt);
 	rb_pgresult = pg_new_result(result, self);
 	pg_result_check(rb_pgresult);
 	return rb_pgresult;
@@ -1175,12 +1235,12 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
  * Connection instance method for versions of 8.1 and higher of libpq
  * uses PQescapeStringConn, which is safer. Avoid calling as a class method,
  * the class method uses the deprecated PQescapeString() API function.
- * 
+ *
  * Returns a SQL-safe version of the String _str_.
- * This is the preferred way to make strings safe for inclusion in 
+ * This is the preferred way to make strings safe for inclusion in
  * SQL queries.
- * 
- * Consider using exec_params, which avoids the need for passing values 
+ *
+ * Consider using exec_params, which avoids the need for passing values
  * inside of SQL commands.
  *
  * Encoding of escaped string will be equal to client encoding of connection.
@@ -1192,7 +1252,7 @@ pgconn_s_escape(VALUE self, VALUE string)
 	size_t size;
 	int error;
 	VALUE result;
-#ifdef M17N_SUPPORTED	
+#ifdef M17N_SUPPORTED
 	rb_encoding* enc;
 #endif
 
@@ -1200,7 +1260,7 @@ pgconn_s_escape(VALUE self, VALUE string)
 
 	escaped = ALLOC_N(char, RSTRING_LEN(string) * 2 + 1);
 	if(rb_obj_class(self) == rb_cPGconn) {
-		size = PQescapeStringConn(pg_get_pgconn(self), escaped, 
+		size = PQescapeStringConn(pg_get_pgconn(self), escaped,
 			RSTRING_PTR(string), RSTRING_LEN(string), &error);
 		if(error) {
 			xfree(escaped);
@@ -1227,7 +1287,7 @@ pgconn_s_escape(VALUE self, VALUE string)
 
 /*
  * call-seq:
- *   conn.escape_bytea( string ) -> String 
+ *   conn.escape_bytea( string ) -> String
  *
  * Connection instance method for versions of 8.1 and higher of libpq
  * uses PQescapeByteaConn, which is safer. Avoid calling as a class method,
@@ -1237,16 +1297,16 @@ pgconn_s_escape(VALUE self, VALUE string)
  * class method.
  *
  * Escapes binary data for use within an SQL command with the type +bytea+.
- * 
+ *
  * Certain byte values must be escaped (but all byte values may be escaped)
  * when used as part of a +bytea+ literal in an SQL statement. In general, to
  * escape a byte, it is converted into the three digit octal number equal to
  * the octet value, and preceded by two backslashes. The single quote (') and
  * backslash (\) characters have special alternative escape sequences.
- * #escape_bytea performs this operation, escaping only the minimally required 
+ * #escape_bytea performs this operation, escaping only the minimally required
  * bytes.
- * 
- * Consider using exec_params, which avoids the need for passing values inside of 
+ *
+ * Consider using exec_params, which avoids the need for passing values inside of
  * SQL commands.
  */
 static VALUE
@@ -1368,6 +1428,61 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 }
 #endif
 
+#ifdef HAVE_PQSETSINGLEROWMODE
+/*
+ * call-seq:
+ *    conn.set_single_row_mode -> self
+ *
+ * To enter single-row mode, call this method immediately after a successful
+ * call of send_query (or a sibling function). This mode selection is effective
+ * only for the currently executing query.
+ * Then call Connection#get_result repeatedly, until it returns nil.
+ *
+ * Each (but the last) received Result has exactly one row and a
+ * Result#result_status of PGRES_SINGLE_TUPLE. The last row has
+ * zero rows and is used to indicate a successful execution of the query.
+ * All of these Result objects will contain the same row description data
+ * (column names, types, etc) that an ordinary Result object for the query
+ * would have.
+ *
+ * *Caution:* While processing a query, the server may return some rows and
+ * then encounter an error, causing the query to be aborted. Ordinarily, pg
+ * discards any such rows and reports only the error. But in single-row mode,
+ * those rows will have already been returned to the application. Hence, the
+ * application will see some Result objects followed by an Error raised in get_result.
+ * For proper transactional behavior, the application must be designed to discard
+ * or undo whatever has been done with the previously-processed rows, if the query
+ * ultimately fails.
+ *
+ * Example:
+ *   conn.send_query( "your SQL command" )
+ *   conn.set_single_row_mode
+ *   loop do
+ *     res = conn.get_result or break
+ *     res.check
+ *     res.each do |row|
+ *       # do something with the received row
+ *     end
+ *   end
+ *
+ */
+static VALUE
+pgconn_set_single_row_mode(VALUE self)
+{
+	PGconn *conn = pg_get_pgconn(self);
+	VALUE error;
+
+	if( PQsetSingleRowMode(conn) == 0 )
+	{
+		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		rb_iv_set(error, "@connection", self);
+		rb_exc_raise(error);
+	}
+
+	return self;
+}
+#endif
+
 /*
  * call-seq:
  *    conn.send_query(sql [, params, result_format ] ) -> nil
@@ -1385,11 +1500,11 @@ pgconn_escape_identifier(VALUE self, VALUE string)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :type => 0, :format => 0 }
- * 
+ *
  * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
- * 
+ *
  * If the types are not specified, they will be inferred by PostgreSQL.
  * Instead of specifying type oids, it's recommended to simply add
  * explicit casts in the query to ensure that the right type is used.
@@ -1449,7 +1564,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 	sym_value = ID2SYM(rb_intern("value"));
 	sym_format = ID2SYM(rb_intern("format"));
 	nParams = (int)RARRAY_LEN(params);
-	paramTypes = ALLOC_N(Oid, nParams); 
+	paramTypes = ALLOC_N(Oid, nParams);
 	paramValues = ALLOC_N(char *, nParams);
 	paramLengths = ALLOC_N(int, nParams);
 	paramFormats = ALLOC_N(int, nParams);
@@ -1496,10 +1611,10 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 			paramFormats[i] = NUM2INT(param_format);
 	}
 
-	result = PQsendQueryParams(conn, StringValuePtr(command), nParams, paramTypes, 
+	result = PQsendQueryParams(conn, StringValuePtr(command), nParams, paramTypes,
 		(const char * const *)paramValues, paramLengths, paramFormats, resultFormat);
 
-	rb_gc_unregister_address(&gc_array);	
+	rb_gc_unregister_address(&gc_array);
 
 	xfree(paramTypes);
 	xfree(paramValues);
@@ -1522,7 +1637,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
  * Sends prepare command asynchronously, and returns immediately.
  * On failure, it raises a PG::Error.
  *
- * +param_types+ is an optional parameter to specify the Oids of the 
+ * +param_types+ is an optional parameter to specify the Oids of the
  * types of the parameters.
  *
  * If the types are not specified, they will be inferred by PostgreSQL.
@@ -1530,7 +1645,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
  * explicit casts in the query to ensure that the right type is used.
  *
  * For example: "SELECT $1::int"
- * 
+ *
  * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
  * inside the SQL query.
  */
@@ -1553,7 +1668,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	if(! NIL_P(in_paramtypes)) {
 		Check_Type(in_paramtypes, T_ARRAY);
 		nParams = (int)RARRAY_LEN(in_paramtypes);
-		paramTypes = ALLOC_N(Oid, nParams); 
+		paramTypes = ALLOC_N(Oid, nParams);
 		for(i = 0; i < nParams; i++) {
 			param = rb_ary_entry(in_paramtypes, i);
 			Check_Type(param, T_FIXNUM);
@@ -1585,7 +1700,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
  * asynchronously, and returns immediately.
  * On failure, it raises a PG::Error.
  *
- * +params+ is an array of the optional bind parameters for the 
+ * +params+ is an array of the optional bind parameters for the
  * SQL query. Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
@@ -1593,7 +1708,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :format => 0 }
- * 
+ *
  * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
@@ -1681,8 +1796,8 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 			paramFormats[i] = NUM2INT(param_format);
 	}
 
-	result = PQsendQueryPrepared(conn, StringValuePtr(name), nParams, 
-		(const char * const *)paramValues, paramLengths, paramFormats, 
+	result = PQsendQueryPrepared(conn, StringValuePtr(name), nParams,
+		(const char * const *)paramValues, paramLengths, paramFormats,
 		resultFormat);
 
 	rb_gc_unregister_address(&gc_array);
@@ -1703,7 +1818,7 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
  * call-seq:
  *    conn.send_describe_prepared( statement_name ) -> nil
  *
- * Asynchronously send _command_ to the server. Does not block. 
+ * Asynchronously send _command_ to the server. Does not block.
  * Use in combination with +conn.get_result+.
  */
 static VALUE
@@ -1725,7 +1840,7 @@ pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
  * call-seq:
  *    conn.send_describe_portal( portal_name ) -> nil
  *
- * Asynchronously send _command_ to the server. Does not block. 
+ * Asynchronously send _command_ to the server. Does not block.
  * Use in combination with +conn.get_result+.
  */
 static VALUE
@@ -1755,8 +1870,8 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
  * Note: call this function repeatedly until it returns +nil+, or else
  * you will not be able to issue further commands.
  *
- * If the optional code block is given, it will be passed <i>result</i> as an argument, 
- * and the PG::Result object will  automatically be cleared when the block terminates. 
+ * If the optional code block is given, it will be passed <i>result</i> as an argument,
+ * and the PG::Result object will  automatically be cleared when the block terminates.
  * In this instance, <code>conn.exec</code> returns the value of the block.
  */
 static VALUE
@@ -1766,7 +1881,7 @@ pgconn_get_result(VALUE self)
 	PGresult *result;
 	VALUE rb_pgresult;
 
-	result = PQgetResult(conn);
+	result = gvl_PQgetResult(conn);
 	if(result == NULL)
 		return Qnil;
 	rb_pgresult = pg_new_result(result, self);
@@ -1818,7 +1933,7 @@ pgconn_is_busy(self)
  * call-seq:
  *    conn.setnonblocking(Boolean) -> nil
  *
- * Sets the nonblocking status of the connection. 
+ * Sets the nonblocking status of the connection.
  * In the blocking state, calls to #send_query
  * will block until the message is sent to the server,
  * but will not wait for the query results.
@@ -1826,7 +1941,7 @@ pgconn_is_busy(self)
  * will return an error if the socket is not ready for
  * writing.
  * Note: This function does not affect #exec, because
- * that function doesn't return until the server has 
+ * that function doesn't return until the server has
  * processed the query and returned the results.
  * Returns +nil+.
  */
@@ -1959,6 +2074,10 @@ pgconn_notifies(VALUE self)
 	relname = rb_tainted_str_new2(notification->relname);
 	be_pid = INT2NUM(notification->be_pid);
 	extra = rb_tainted_str_new2(notification->extra);
+#ifdef M17N_SUPPORTED
+	ENCODING_SET( relname, rb_enc_to_index(pg_conn_enc_get( conn )) );
+	ENCODING_SET( extra, rb_enc_to_index(pg_conn_enc_get( conn )) );
+#endif
 
 	rb_hash_aset(hash, sym_relname, relname);
 	rb_hash_aset(hash, sym_be_pid, be_pid);
@@ -1968,9 +2087,10 @@ pgconn_notifies(VALUE self)
 	return hash;
 }
 
+/* Win32 + Ruby 1.8 */
+#if !defined( HAVE_RUBY_VM_H ) && defined( _WIN32 )
 
-#ifdef _WIN32
-/* 
+/*
  * Duplicate the sockets from libpq and create temporary CRT FDs
  */
 void create_crt_fd(fd_set *os_set, fd_set *crt_set)
@@ -2004,6 +2124,149 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
 }
 #endif
 
+/* Win32 + Ruby 1.9+ */
+#if defined( HAVE_RUBY_VM_H ) && defined( _WIN32 )
+/*
+ * On Windows, use platform-specific strategies to wait for the socket
+ * instead of rb_thread_select().
+ */
+
+int rb_w32_wait_events( HANDLE *events, int num, DWORD timeout );
+
+/* If WIN32 and Ruby 1.9 do not use rb_thread_select() which sometimes hangs
+ * and does not wait (nor sleep) any time even if timeout is given.
+ * Instead use the Winsock events and rb_w32_wait_events(). */
+
+static void *
+wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readable)(PGconn *) )
+{
+	int sd = PQsocket( conn );
+	void *retval;
+	DWORD timeout_milisec = INFINITE;
+	DWORD wait_ret;
+	WSAEVENT hEvent;
+
+	if ( sd < 0 )
+		rb_bug( "PQsocket(conn): couldn't fetch the connection's socket!" );
+
+	hEvent = WSACreateEvent();
+
+	if ( ptimeout ) {
+		timeout_milisec = (DWORD)( ptimeout->tv_sec * 1e3 + ptimeout->tv_usec / 1e3 );
+	}
+
+	/* Check for connection errors (PQisBusy is true on connection errors) */
+	if( PQconsumeInput(conn) == 0 ) {
+		WSACloseEvent( hEvent );
+		rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
+	}
+
+	while ( !(retval=is_readable(conn)) ) {
+		if ( WSAEventSelect(sd, hEvent, FD_READ|FD_CLOSE) == SOCKET_ERROR ) {
+			WSACloseEvent( hEvent );
+			rb_raise( rb_ePGerror, "WSAEventSelect socket error: %d", WSAGetLastError() );
+		}
+
+		wait_ret = rb_w32_wait_events( &hEvent, 1, timeout_milisec );
+
+		if ( wait_ret == WAIT_TIMEOUT ) {
+			WSACloseEvent( hEvent );
+			return NULL;
+		} else if ( wait_ret == WAIT_OBJECT_0 ) {
+			/* The event we were waiting for. */
+		} else if ( wait_ret == WAIT_FAILED ) {
+			WSACloseEvent( hEvent );
+			rb_raise( rb_ePGerror, "Wait on socket error (WaitForMultipleObjects): %d", GetLastError() );
+		} else {
+			WSACloseEvent( hEvent );
+			rb_raise( rb_ePGerror, "Wait on socket abandoned (WaitForMultipleObjects)" );
+		}
+
+		/* Check for connection errors (PQisBusy is true on connection errors) */
+		if ( PQconsumeInput(conn) == 0 ) {
+			WSACloseEvent( hEvent );
+			rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
+		}
+	}
+
+	WSACloseEvent( hEvent );
+	return retval;
+}
+
+#else
+
+/* non Win32 or Win32+Ruby-1.8 */
+
+static void *
+wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
+{
+	int sd = PQsocket( conn );
+	int ret;
+	void *retval;
+	rb_fdset_t sd_rset;
+#ifdef _WIN32
+	rb_fdset_t crt_sd_rset;
+#endif
+
+	if ( sd < 0 )
+		rb_bug( "PQsocket(conn): couldn't fetch the connection's socket!" );
+
+	/* Check for connection errors (PQisBusy is true on connection errors) */
+	if ( PQconsumeInput(conn) == 0 )
+		rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
+
+  rb_fd_init( &sd_rset );
+
+	while ( !(retval=is_readable(conn)) ) {
+		rb_fd_zero( &sd_rset );
+		rb_fd_set( sd, &sd_rset );
+
+#ifdef _WIN32
+		/* Ruby's FD_SET is modified on win32 to convert a file descriptor
+		 * to osfhandle, but we already get a osfhandle from PQsocket().
+		 * Therefore it's overwritten here. */
+		sd_rset.fd_array[0] = sd;
+		create_crt_fd(&sd_rset, &crt_sd_rset);
+#endif
+
+		/* Wait for the socket to become readable before checking again */
+		ret = rb_thread_fd_select( sd+1, &sd_rset, NULL, NULL, ptimeout );
+
+#ifdef _WIN32
+		cleanup_crt_fd(&sd_rset, &crt_sd_rset);
+#endif
+
+		if ( ret < 0 ){
+			rb_fd_term( &sd_rset );
+			rb_sys_fail( "rb_thread_select()" );
+		}
+
+		/* Return false if the select() timed out */
+		if ( ret == 0 ){
+			rb_fd_term( &sd_rset );
+			return NULL;
+		}
+
+		/* Check for connection errors (PQisBusy is true on connection errors) */
+		if ( PQconsumeInput(conn) == 0 ){
+			rb_fd_term( &sd_rset );
+			rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
+		}
+	}
+
+	rb_fd_term( &sd_rset );
+	return retval;
+}
+
+
+#endif
+
+static void *
+notify_readable(PGconn *conn)
+{
+	return (void*)PQnotifies(conn);
+}
+
 /*
  * call-seq:
  *    conn.wait_for_notify( [ timeout ] ) -> String
@@ -2017,30 +2280,21 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
  * Returns +nil+ if _timeout_ is reached, the name of the NOTIFY
  * event otherwise.  If used in block form, passes the name of the
  * NOTIFY +event+ and the generating +pid+ into the block.
- * 
+ *
  * Under PostgreSQL 9.0 and later, if the notification is sent with
  * the optional +payload+ string, it will be given to the block as the
  * third argument.
- * 
+ *
  */
 static VALUE
 pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 {
 	PGconn *conn = pg_get_pgconn( self );
-	PGnotify *notification;
-	int sd = PQsocket( conn );
-	int ret;
+	PGnotify *pnotification;
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
 	VALUE timeout_in = Qnil, relname = Qnil, be_pid = Qnil, extra = Qnil;
 	double timeout_sec;
-	fd_set sd_rset;
-#ifdef _WIN32
-	fd_set crt_sd_rset;
-#endif
-
-	if ( sd < 0 )
-		rb_bug( "PQsocket(conn): couldn't fetch the connection's socket!" );
 
 	rb_scan_args( argc, argv, "01", &timeout_in );
 
@@ -2051,43 +2305,25 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 		ptimeout = &timeout;
 	}
 
-	/* Check for notifications */
-	while ( (notification = PQnotifies(conn)) == NULL ) {
-		FD_ZERO( &sd_rset );
-		FD_SET( sd, &sd_rset );
-
-#ifdef _WIN32
-		create_crt_fd(&sd_rset, &crt_sd_rset);
-#endif
+	pnotification = (PGnotify*) wait_socket_readable( conn, ptimeout, notify_readable);
 
-		/* Wait for the socket to become readable before checking again */
-		ret = rb_thread_select( sd+1, &sd_rset, NULL, NULL, ptimeout );
+	/* Return nil if the select timed out */
+	if ( !pnotification ) return Qnil;
 
-#ifdef _WIN32
-		cleanup_crt_fd(&sd_rset, &crt_sd_rset);
+	relname = rb_tainted_str_new2( pnotification->relname );
+#ifdef M17N_SUPPORTED
+	ENCODING_SET( relname, rb_enc_to_index(pg_conn_enc_get( conn )) );
 #endif
-
-		if ( ret < 0 )
-			rb_sys_fail( 0 );
-
-		/* Return nil if the select timed out */
-		if ( ret == 0 ) return Qnil;
-
-		/* Read the socket */
-		if ( (ret = PQconsumeInput(conn)) != 1 )
-			rb_raise( rb_ePGerror, "PQconsumeInput == %d: %s", ret, PQerrorMessage(conn) );
-	}
-
-	relname = rb_tainted_str_new2( notification->relname );
-	ASSOCIATE_INDEX( relname, self );
-	be_pid = INT2NUM( notification->be_pid );
+	be_pid = INT2NUM( pnotification->be_pid );
 #ifdef HAVE_ST_NOTIFY_EXTRA
-	if ( *notification->extra ) {
-		extra = rb_tainted_str_new2( notification->extra );
-		ASSOCIATE_INDEX( extra, self );
+	if ( *pnotification->extra ) {
+		extra = rb_tainted_str_new2( pnotification->extra );
+#ifdef M17N_SUPPORTED
+		ENCODING_SET( extra, rb_enc_to_index(pg_conn_enc_get( conn )) );
+#endif
 	}
 #endif
-	PQfreemem( notification );
+	PQfreemem( pnotification );
 
 	if ( rb_block_given_p() )
 		rb_yield_values( 3, relname, be_pid, extra );
@@ -2116,7 +2352,7 @@ pgconn_put_copy_data(self, buffer)
 	PGconn *conn = pg_get_pgconn(self);
 	Check_Type(buffer, T_STRING);
 
-	ret = PQputCopyData(conn, RSTRING_PTR(buffer), (int)RSTRING_LEN(buffer));
+	ret = gvl_PQputCopyData(conn, RSTRING_PTR(buffer), (int)RSTRING_LEN(buffer));
 	if(ret == -1) {
 		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
@@ -2138,7 +2374,7 @@ pgconn_put_copy_data(self, buffer)
  * Returns true if the end-of-data was sent, false if it was
  * not sent (false is only possible if the connection
  * is in nonblocking mode, and this command would block).
- */ 
+ */
 static VALUE
 pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
 {
@@ -2153,7 +2389,7 @@ pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
 	else
 		error_message = StringValuePtr(str);
 
-	ret = PQputCopyEnd(conn, error_message);
+	ret = gvl_PQputCopyEnd(conn, error_message);
 	if(ret == -1) {
 		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
@@ -2167,7 +2403,7 @@ pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
  *    conn.get_copy_data( [ async = false ] ) -> String
  *
  * Return a string containing one row of data, +nil+
- * if the copy is done, or +false+ if the call would 
+ * if the copy is done, or +false+ if the call would
  * block (only possible if _async_ is true).
  *
  */
@@ -2187,7 +2423,7 @@ pgconn_get_copy_data(int argc, VALUE *argv, VALUE self )
 	else
 		async = (async_in == Qfalse || async_in == Qnil) ? 0 : 1;
 
-	ret = PQgetCopyData(conn, &buffer, async);
+	ret = gvl_PQgetCopyData(conn, &buffer, async);
 	if(ret == -2) { /* error */
 		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
@@ -2225,8 +2461,8 @@ pgconn_set_error_verbosity(VALUE self, VALUE in_verbosity)
 /*
  * call-seq:
  *    conn.trace( stream ) -> nil
- * 
- * Enables tracing message passing between backend. The 
+ *
+ * Enables tracing message passing between backend. The
  * trace message will be written to the stream _stream_,
  * which must implement a method +fileno+ that returns
  * a writable file descriptor.
@@ -2269,7 +2505,7 @@ pgconn_trace(VALUE self, VALUE stream)
 /*
  * call-seq:
  *    conn.untrace() -> nil
- * 
+ *
  * Disables the message tracing.
  */
 static VALUE
@@ -2288,15 +2524,20 @@ pgconn_untrace(VALUE self)
  * Notice callback proxy function -- delegate the callback to the
  * currently-registered Ruby notice_receiver object.
  */
-static void
+void
 notice_receiver_proxy(void *arg, const PGresult *result)
 {
 	VALUE proc;
 	VALUE self = (VALUE)arg;
 
 	if ((proc = rb_iv_get(self, "@notice_receiver")) != Qnil) {
-		rb_funcall(proc, rb_intern("call"), 1, 
-			Data_Wrap_Struct(rb_cPGresult, NULL, NULL, (PGresult*)result));
+		VALUE val = Data_Wrap_Struct(rb_cPGresult, NULL, NULL, (PGresult*)result);
+#ifdef M17N_SUPPORTED
+		PGconn *conn = pg_get_pgconn( self );
+		rb_encoding *enc = pg_conn_enc_get( conn );
+		ENCODING_SET( val, rb_enc_to_index(enc) );
+#endif
+		rb_funcall(proc, rb_intern("call"), 1, val);
 	}
 	return;
 }
@@ -2313,15 +2554,15 @@ notice_receiver_proxy(void *arg, const PGresult *result)
  * application can override this behavior by supplying its own handling
  * function.
  *
- * For historical reasons, there are two levels of notice handling, called the 
- * notice receiver and notice processor. The default behavior is for the notice 
- * receiver to format the notice and pass a string to the notice processor for 
- * printing. However, an application that chooses to provide its own notice 
- * receiver will typically ignore the notice processor layer and just do all 
+ * For historical reasons, there are two levels of notice handling, called the
+ * notice receiver and notice processor. The default behavior is for the notice
+ * receiver to format the notice and pass a string to the notice processor for
+ * printing. However, an application that chooses to provide its own notice
+ * receiver will typically ignore the notice processor layer and just do all
  * the work in the notice receiver.
  *
  * This function takes a new block to act as the handler, which should
- * accept a single parameter that will be a PG::Result object, and returns 
+ * accept a single parameter that will be a PG::Result object, and returns
  * the Proc object previously set, or +nil+ if it was previously the default.
  *
  * If you pass no arguments, it will reset the handler to the default.
@@ -2336,8 +2577,8 @@ pgconn_set_notice_receiver(VALUE self)
 	VALUE proc, old_proc;
 	PGconn *conn = pg_get_pgconn(self);
 
-	/* If default_notice_receiver is unset, assume that the current 
-	 * notice receiver is the default, and save it to a global variable. 
+	/* If default_notice_receiver is unset, assume that the current
+	 * notice receiver is the default, and save it to a global variable.
 	 * This should not be a problem because the default receiver is
 	 * always the same, so won't vary among connections.
 	 */
@@ -2347,7 +2588,7 @@ pgconn_set_notice_receiver(VALUE self)
 	old_proc = rb_iv_get(self, "@notice_receiver");
 	if( rb_block_given_p() ) {
 		proc = rb_block_proc();
-		PQsetNoticeReceiver(conn, notice_receiver_proxy, (void *)self);
+		PQsetNoticeReceiver(conn, gvl_notice_receiver_proxy, (void *)self);
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
@@ -2363,14 +2604,20 @@ pgconn_set_notice_receiver(VALUE self)
  * Notice callback proxy function -- delegate the callback to the
  * currently-registered Ruby notice_processor object.
  */
-static void
+void
 notice_processor_proxy(void *arg, const char *message)
 {
 	VALUE proc;
 	VALUE self = (VALUE)arg;
 
 	if ((proc = rb_iv_get(self, "@notice_processor")) != Qnil) {
-		rb_funcall(proc, rb_intern("call"), 1, rb_tainted_str_new2(message));
+		VALUE message_str = rb_tainted_str_new2(message);
+#ifdef M17N_SUPPORTED
+		PGconn *conn = pg_get_pgconn( self );
+		rb_encoding *enc = pg_conn_enc_get( conn );
+		ENCODING_SET( message_str, rb_enc_to_index(enc) );
+#endif
+		rb_funcall(proc, rb_intern("call"), 1, message_str);
 	}
 	return;
 }
@@ -2382,9 +2629,9 @@ notice_processor_proxy(void *arg, const char *message)
  * See #set_notice_receiver for the desription of what this and the
  * notice_processor methods do.
  *
- * This function takes a new block to act as the notice processor and returns 
+ * This function takes a new block to act as the notice processor and returns
  * the Proc object previously set, or +nil+ if it was previously the default.
- * The block should accept a single PG::Result object.
+ * The block should accept a single String object.
  *
  * If you pass no arguments, it will reset the handler to the default.
  */
@@ -2394,8 +2641,8 @@ pgconn_set_notice_processor(VALUE self)
 	VALUE proc, old_proc;
 	PGconn *conn = pg_get_pgconn(self);
 
-	/* If default_notice_processor is unset, assume that the current 
-	 * notice processor is the default, and save it to a global variable. 
+	/* If default_notice_processor is unset, assume that the current
+	 * notice processor is the default, and save it to a global variable.
 	 * This should not be a problem because the default processor is
 	 * always the same, so won't vary among connections.
 	 */
@@ -2405,7 +2652,7 @@ pgconn_set_notice_processor(VALUE self)
 	old_proc = rb_iv_get(self, "@notice_processor");
 	if( rb_block_given_p() ) {
 		proc = rb_block_proc();
-		PQsetNoticeProcessor(conn, notice_processor_proxy, (void *)self);
+		PQsetNoticeProcessor(conn, gvl_notice_processor_proxy, (void *)self);
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
@@ -2420,7 +2667,7 @@ pgconn_set_notice_processor(VALUE self)
 /*
  * call-seq:
  *    conn.get_client_encoding() -> String
- * 
+ *
  * Returns the client encoding as a String.
  */
 static VALUE
@@ -2434,7 +2681,7 @@ pgconn_get_client_encoding(VALUE self)
 /*
  * call-seq:
  *    conn.set_client_encoding( encoding )
- * 
+ *
  * Sets the client encoding to the _encoding_ String.
  */
 static VALUE
@@ -2456,7 +2703,7 @@ pgconn_set_client_encoding(VALUE self, VALUE str)
  *    conn.transaction { |conn| ... } -> nil
  *
  * Executes a +BEGIN+ at the start of the block,
- * and a +COMMIT+ at the end of the block, or 
+ * and a +COMMIT+ at the end of the block, or
  * +ROLLBACK+ if any exception occurs.
  */
 static VALUE
@@ -2468,18 +2715,18 @@ pgconn_transaction(VALUE self)
 	int status;
 
 	if (rb_block_given_p()) {
-		result = PQexec(conn, "BEGIN");
+		result = gvl_PQexec(conn, "BEGIN");
 		rb_pgresult = pg_new_result(result, self);
 		pg_result_check(rb_pgresult);
 		rb_protect(rb_yield, self, &status);
 		if(status == 0) {
-			result = PQexec(conn, "COMMIT");
+			result = gvl_PQexec(conn, "COMMIT");
 			rb_pgresult = pg_new_result(result, self);
 			pg_result_check(rb_pgresult);
 		}
 		else {
 			/* exception occurred, ROLLBACK and re-raise */
-			result = PQexec(conn, "ROLLBACK");
+			result = gvl_PQexec(conn, "ROLLBACK");
 			rb_pgresult = pg_new_result(result, self);
 			pg_result_check(rb_pgresult);
 			rb_jump_tag(status);
@@ -2502,7 +2749,7 @@ pgconn_transaction(VALUE self)
  * Returns a string that is safe for inclusion in a SQL query as an
  * identifier. Note: this is not a quote function for values, but for
  * identifiers.
- * 
+ *
  * For example, in a typical SQL query: <tt>SELECT FOO FROM MYTABLE</tt>
  * The identifier <tt>FOO</tt> is folded to lower case, so it actually
  * means <tt>foo</tt>. If you really want to access the case-sensitive
@@ -2510,7 +2757,7 @@ pgconn_transaction(VALUE self)
  * <tt>PG::Connection.quote_ident('FOO')</tt>, which will return <tt>"FOO"</tt>
  * (with double-quotes). PostgreSQL will see the double-quotes, and
  * it will not fold to lower case.
- * 
+ *
  * Similarly, this function also protects against special characters,
  * and other things that might allow SQL injection if the identifier
  * comes from an untrusted source.
@@ -2528,13 +2775,13 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
 	UNUSED( self );
 
 	if(strlen(str) >= NAMEDATALEN) {
-		rb_raise(rb_eArgError, 
+		rb_raise(rb_eArgError,
 			"Input string is longer than NAMEDATALEN-1 (%d)",
 			NAMEDATALEN-1);
 	}
 	buffer[j++] = '"';
 	for(i = 0; i < strlen(str) && str[i]; i++) {
-		if(str[i] == '"') 
+		if(str[i] == '"')
 			buffer[j++] = '"';
 		buffer[j++] = str[i];
 	}
@@ -2545,169 +2792,39 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
 }
 
 
-#ifndef _WIN32
+static void *
+get_result_readable(PGconn *conn)
+{
+	return PQisBusy(conn) ? NULL : (void*)1;
+}
+
 
 /*
  * call-seq:
  *    conn.block( [ timeout ] ) -> Boolean
  *
- * Blocks until the server is no longer busy, or until the 
+ * Blocks until the server is no longer busy, or until the
  * optional _timeout_ is reached, whichever comes first.
  * _timeout_ is measured in seconds and can be fractional.
- * 
+ *
  * Returns +false+ if _timeout_ is reached, +true+ otherwise.
- * 
+ *
  * If +true+ is returned, +conn.is_busy+ will return +false+
  * and +conn.get_result+ will not block.
  */
 static VALUE
 pgconn_block( int argc, VALUE *argv, VALUE self ) {
 	PGconn *conn = pg_get_pgconn( self );
-	int sd = PQsocket( conn );
-	int ret;
 
-	/* If WIN32 and Ruby 1.9 do not use rb_thread_select() which sometimes hangs 
+	/* If WIN32 and Ruby 1.9 do not use rb_thread_select() which sometimes hangs
 	 * and does not wait (nor sleep) any time even if timeout is given.
 	 * Instead use the Winsock events and rb_w32_wait_events(). */
 
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
-	fd_set sd_rset;
-	VALUE timeout_in;
-	double timeout_sec;
-
-	if ( rb_scan_args(argc, argv, "01", &timeout_in) == 1 ) {
-		timeout_sec = NUM2DBL( timeout_in );
-		timeout.tv_sec = (time_t)timeout_sec;
-		timeout.tv_usec = (suseconds_t)((timeout_sec - (long)timeout_sec) * 1e6);
-		ptimeout = &timeout;
-	}
-
-	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if ( PQconsumeInput(conn) == 0 )
-		rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
-
-	while ( PQisBusy(conn) ) {
-		FD_ZERO( &sd_rset );
-		FD_SET( sd, &sd_rset );
-
-		if ( (ret = rb_thread_select( sd+1, &sd_rset, NULL, NULL, ptimeout )) < 0 )
-			rb_sys_fail( "rb_thread_select()" ); /* Raises */
-
-		/* Return false if there was a timeout argument and the select() timed out */
-		if ( ret == 0 && argc )
-			return Qfalse;
-
-		/* Check for connection errors (PQisBusy is true on connection errors) */
-		if ( PQconsumeInput(conn) == 0 )
-			rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
-	}
-
-	return Qtrue;
-}
-
-
-#else /* _WIN32 */
-
-/*
- * Win32 PG::Connection#block -- on Windows, use platform-specific strategies to wait for the socket 
- * instead of rb_thread_select().
- */
-
-/* Win32 + Ruby 1.9+ */
-#ifdef HAVE_RUBY_VM_H
-
-int rb_w32_wait_events( HANDLE *events, int num, DWORD timeout );
-
-/* If WIN32 and Ruby 1.9 do not use rb_thread_select() which sometimes hangs 
- * and does not wait (nor sleep) any time even if timeout is given.
- * Instead use the Winsock events and rb_w32_wait_events(). */
-
-static VALUE
-pgconn_block( int argc, VALUE *argv, VALUE self ) {
-	PGconn *conn = pg_get_pgconn( self );
-	int sd = PQsocket( conn );
-	int ret;
-
-	DWORD timeout_milisec = INFINITY;
-	DWORD wait_ret;
-	WSAEVENT hEvent;
-	VALUE timeout_in;
-	double timeout_sec;
-
-	hEvent = WSACreateEvent();
-
-	if ( rb_scan_args(argc, argv, "01", &timeout_in) == 1 ) {
-		timeout_sec = NUM2DBL( timeout_in );
-		timeout_milisec = (DWORD)( (timeout_sec - (DWORD)timeout_sec) * 1e3 );
-	}
-
-	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if( PQconsumeInput(conn) == 0 ) {
-		WSACloseEvent( hEvent );
-		rb_raise( rb_ePGerror, PQerrorMessage(conn) );
-	}
-
-	while ( PQisBusy(conn) ) {
-		if ( WSAEventSelect(sd, hEvent, FD_READ|FD_CLOSE) == SOCKET_ERROR ) {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, "WSAEventSelect socket error: %d", WSAGetLastError() );
-		}
-
-		wait_ret = rb_w32_wait_events( &hEvent, 1, 100 );
-
-		if ( wait_ret == WAIT_TIMEOUT ) {
-			ret = 0;
-		} else if ( wait_ret == WAIT_OBJECT_0 ) {
-			ret = 1;
-		} else if ( wait_ret == WAIT_FAILED ) {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, "Wait on socket error (WaitForMultipleObjects): %d", GetLastError() );
-		} else {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, "Wait on socket abandoned (WaitForMultipleObjects)" );
-		}
-
-		/* Return false if there was a timeout argument and the select() timed out */
-		if ( ret == 0 && argc ) {
-			WSACloseEvent( hEvent );
-			return Qfalse;
-		}
-
-		/* Check for connection errors (PQisBusy is true on connection errors) */
-		if ( PQconsumeInput(conn) == 0 ) {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, PQerrorMessage(conn) );
-		}
-	}
-
-	WSACloseEvent( hEvent );
-
-	return Qtrue;
-}
-
-#else /* Win32 + Ruby < 1.9 */
-
-static VALUE
-pgconn_block( int argc, VALUE *argv, VALUE self ) {
-	PGconn *conn = pg_get_pgconn( self );
-	int sd = PQsocket( conn );
-	int ret;
-
-	struct timeval timeout;
-	struct timeval *ptimeout = NULL;
-	fd_set sd_rset;
-	fd_set crt_sd_rset;
 	VALUE timeout_in;
 	double timeout_sec;
-
-	/* Always set a timeout, as rb_thread_select() sometimes
-	 * doesn't return when a second ruby thread is running although data
-	 * could be read. So we use timeout-based polling instead.
-	 */
-	timeout.tv_sec = 0;
-	 timeout.tv_usec = 10000; /* 10ms */
-	ptimeout = &timeout;
+	void *ret;
 
 	if ( rb_scan_args(argc, argv, "01", &timeout_in) == 1 ) {
 		timeout_sec = NUM2DBL( timeout_in );
@@ -2716,33 +2833,14 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
 		ptimeout = &timeout;
 	}
 
-	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if( PQconsumeInput(conn) == 0 )
-		rb_raise( rb_ePGerror, PQerrorMessage(conn) );
+	ret = wait_socket_readable( conn, ptimeout, get_result_readable);
 
-	while ( PQisBusy(conn) ) {
-		FD_ZERO( &sd_rset );
-		FD_SET( sd, &sd_rset );
-
-		create_crt_fd( &sd_rset, &crt_sd_rset );
-		ret = rb_thread_select( sd+1, &sd_rset, NULL, NULL, ptimeout );
-		cleanup_crt_fd( &sd_rset, &crt_sd_rset );
-
-		/* Return false if there was a timeout argument and the select() timed out */
-		if ( ret == 0 && argc )
-			return Qfalse;
-
-		/* Check for connection errors (PQisBusy is true on connection errors) */
-		if ( PQconsumeInput(conn) == 0 )
-			rb_raise( rb_ePGerror, PQerrorMessage(conn) );
-	}
+	if( !ret )
+		return Qfalse;
 
 	return Qtrue;
 }
 
-#endif /* Ruby 1.9 */
-#endif /* Win32 */
-
 
 /*
  * call-seq:
@@ -2767,7 +2865,7 @@ pgconn_get_last_result(VALUE self)
 
 
 	cur = prev = NULL;
-	while ((cur = PQgetResult(conn)) != NULL) {
+	while ((cur = gvl_PQgetResult(conn)) != NULL) {
 		int status;
 
 		if (prev) PQclear(prev);
@@ -2793,8 +2891,8 @@ pgconn_get_last_result(VALUE self)
  *    conn.async_exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * This function has the same behavior as #exec,
- * except that it's implemented using asynchronous command 
- * processing and ruby's +rb_thread_select+ in order to 
+ * except that it's implemented using asynchronous command
+ * processing and ruby's +rb_thread_select+ in order to
  * allow other threads to process while waiting for the
  * server to complete the request.
  */
@@ -2922,7 +3020,7 @@ pgconn_loexport(VALUE self, VALUE lo_oid, VALUE filename)
  * call-seq:
  *    conn.lo_open( oid, [mode] ) -> Fixnum
  *
- * Open a large object of _oid_. Returns a large object descriptor 
+ * Open a large object of _oid_. Returns a large object descriptor
  * instance on success. The _mode_ argument specifies the mode for
  * the opened large object,which is either +INV_READ+, or +INV_WRITE+.
  *
@@ -2968,7 +3066,7 @@ pgconn_lowrite(VALUE self, VALUE in_lo_desc, VALUE buffer)
 	if( RSTRING_LEN(buffer) < 0) {
 		rb_raise(rb_ePGerror, "write buffer zero string");
 	}
-	if((n = lo_write(conn, fd, StringValuePtr(buffer), 
+	if((n = lo_write(conn, fd, StringValuePtr(buffer),
 				RSTRING_LEN(buffer))) < 0) {
 		rb_raise(rb_ePGerror, "lo_write failed: %s", PQerrorMessage(conn));
 	}
@@ -3250,7 +3348,7 @@ init_pg_connection()
 {
 	rb_cPGconn = rb_define_class_under( rb_mPG, "Connection", rb_cObject );
 	rb_include_module(rb_cPGconn, rb_mPGconstants);
-	
+
 	/******     PG::Connection CLASS METHODS     ******/
 	rb_define_alloc_func( rb_cPGconn, pgconn_s_allocate );
 
@@ -3304,6 +3402,7 @@ init_pg_connection()
 	/******     PG::Connection INSTANCE METHODS: Command Execution     ******/
 	rb_define_method(rb_cPGconn, "exec", pgconn_exec, -1);
 	rb_define_alias(rb_cPGconn, "query", "exec");
+	rb_define_method(rb_cPGconn, "exec_params", pgconn_exec_params, -1);
 	rb_define_method(rb_cPGconn, "prepare", pgconn_prepare, -1);
 	rb_define_method(rb_cPGconn, "exec_prepared", pgconn_exec_prepared, -1);
 	rb_define_method(rb_cPGconn, "describe_prepared", pgconn_describe_prepared, 1);
@@ -3319,6 +3418,9 @@ init_pg_connection()
 #endif
 	rb_define_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
 	rb_define_method(rb_cPGconn, "unescape_bytea", pgconn_s_unescape_bytea, 1);
+#ifdef HAVE_PQSETSINGLEROWMODE
+	rb_define_method(rb_cPGconn, "set_single_row_mode", pgconn_set_single_row_mode, 0);
+#endif
 
 	/******     PG::Connection INSTANCE METHODS: Asynchronous Command Processing     ******/
 	rb_define_method(rb_cPGconn, "send_query", pgconn_send_query, -1);
@@ -3404,4 +3506,3 @@ init_pg_connection()
 
 }
 
-