pg 0.11.0-x86-mingw32 → 0.12.0-x86-mingw32

data/Rakefile.cross

@@ -0,0 +1,234 @@
+#!/usr/bin/env rake
+
+require 'uri'
+require 'tempfile'
+require 'rbconfig'
+require 'rake/clean'
+require 'rake/extensiontask'
+require 'rake/extensioncompiler'
+
+MISCDIR = BASEDIR + 'misc'
+
+NUM_CPUS = if File.exist?('/proc/cpuinfo')
+  File.read('/proc/cpuinfo').scan('processor').length
+elsif RUBY_PLATFORM.include?( 'darwin' )
+  `system_profiler SPHardwareDataType | grep 'Cores' | awk '{print $5}'`.chomp
+else
+  1
+end
+
+# Cross-compilation constants
+OPENSSL_VERSION            = ENV['OPENSSL_VERSION'] || '1.0.0e'
+POSTGRESQL_VERSION         = ENV['POSTGRESQL_VERSION'] || '9.1.1'
+
+COMPILE_HOME               = Pathname( "./build" ).expand_path
+STATIC_SOURCESDIR          = COMPILE_HOME + 'sources'
+STATIC_BUILDDIR            = COMPILE_HOME + 'builds'
+
+# Static OpenSSL build vars
+STATIC_OPENSSL_BUILDDIR    = STATIC_BUILDDIR + "openssl-#{OPENSSL_VERSION}"
+
+OPENSSL_SOURCE_URI         =
+  URI( "http://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz" )
+OPENSSL_TARBALL            = STATIC_SOURCESDIR + File.basename( OPENSSL_SOURCE_URI.path )
+OPENSSL_MAKEFILE           = STATIC_OPENSSL_BUILDDIR + 'Makefile'
+
+LIBSSLEAY32                = STATIC_OPENSSL_BUILDDIR + 'libssleay32.a'
+LIBEAY32                   = STATIC_OPENSSL_BUILDDIR + 'libeay32.a'
+
+OPENSSL_PATCHES            = Rake::FileList[ MISCDIR + "openssl-#{OPENSSL_VERSION}.*.patch" ]
+
+# Static PostgreSQL build vars
+STATIC_POSTGRESQL_BUILDDIR = STATIC_BUILDDIR + "postgresql-#{POSTGRESQL_VERSION}"
+POSTGRESQL_SOURCE_URI      = begin
+  uristring = "http://ftp9.us.postgresql.org/pub/mirrors/postgresql/source/" +
+    "v%s/postgresql-%s.tar.bz2" % [ POSTGRESQL_VERSION, POSTGRESQL_VERSION ]
+  URI( uristring )
+end
+POSTGRESQL_TARBALL         = STATIC_SOURCESDIR + File.basename( POSTGRESQL_SOURCE_URI.path )
+
+STATIC_POSTGRESQL_SRCDIR   = STATIC_POSTGRESQL_BUILDDIR + 'src'
+STATIC_POSTGRESQL_LIBDIR   = STATIC_POSTGRESQL_SRCDIR + 'interfaces/libpq'
+STATIC_POSTGRESQL_INCDIR   = STATIC_POSTGRESQL_SRCDIR + 'include'
+
+POSTGRESQL_GLOBAL_MAKEFILE = STATIC_POSTGRESQL_SRCDIR + 'Makefile.global'
+POSTGRESQL_SHLIB_MAKEFILE  = STATIC_POSTGRESQL_SRCDIR + 'Makefile.shlib'
+POSTGRESQL_SHLIB_MF_ORIG   = STATIC_POSTGRESQL_SRCDIR + 'Makefile.shlib.orig'
+POSTGRESQL_LIB             = STATIC_POSTGRESQL_LIBDIR + 'libpq.a'
+
+CROSS_PREFIX = Rake::ExtensionCompiler.mingw_host
+
+
+# clean intermediate files and folders
+CLEAN.include( STATIC_BUILDDIR.to_s )
+
+
+ENV['RUBY_CC_VERSION'] ||= '1.8.7:1.9.3'
+
+def download(url, save_to)
+  part = save_to+".part"
+  sh "wget #{url.to_s.inspect} -O #{part.inspect} || curl #{url.to_s.inspect} -o #{part.inspect}"
+  FileUtils.mv part, save_to
+end
+
+def run(*args)
+  sh *args
+end
+
+#####################################################################
+### C R O S S - C O M P I L A T I O N - T A S K S
+#####################################################################
+
+
+directory STATIC_SOURCESDIR.to_s
+
+#
+# Static OpenSSL build tasks
+#
+directory STATIC_OPENSSL_BUILDDIR.to_s
+
+# openssl source file should be stored there
+file OPENSSL_TARBALL => STATIC_SOURCESDIR do |t|
+  download( OPENSSL_SOURCE_URI, t.name )
+end
+
+# Extract the openssl builds
+file STATIC_OPENSSL_BUILDDIR => OPENSSL_TARBALL do |t|
+  puts "extracting %s to %s" % [ OPENSSL_TARBALL, STATIC_OPENSSL_BUILDDIR.parent ]
+  STATIC_OPENSSL_BUILDDIR.mkpath
+  run 'tar', '-xzf', OPENSSL_TARBALL.to_s, '-C', STATIC_OPENSSL_BUILDDIR.parent.to_s
+  OPENSSL_MAKEFILE.unlink if OPENSSL_MAKEFILE.exist?
+
+  OPENSSL_PATCHES.each do |patchfile|
+    puts "  applying patch #{patchfile}..."
+    run 'patch', '-Np1', '-d', STATIC_OPENSSL_BUILDDIR.to_s,
+      '-i', File.expand_path( patchfile, BASEDIR )
+  end
+end
+
+CMD_PRELUDE = [
+  'env',
+  "CC=#{CROSS_PREFIX}-gcc",
+  "CFLAGS=-DDSO_WIN32",
+  "AR=#{CROSS_PREFIX}-ar",
+  "RANLIB=#{CROSS_PREFIX}-ranlib"
+]
+
+
+# generate the makefile in a clean build location
+file OPENSSL_MAKEFILE => STATIC_OPENSSL_BUILDDIR do |t|
+  Dir.chdir( STATIC_OPENSSL_BUILDDIR ) do
+    cmd = CMD_PRELUDE.dup
+    cmd << "./Configure" << 'mingw'
+
+    run( *cmd )
+  end
+end
+
+desc "compile static openssl libraries"
+task :openssl_libs => [ LIBSSLEAY32, LIBEAY32 ]
+
+task :compile_static_openssl => OPENSSL_MAKEFILE do |t|
+  Dir.chdir( STATIC_OPENSSL_BUILDDIR ) do
+    cmd = CMD_PRELUDE.dup
+    cmd << 'make' << "-j#{NUM_CPUS}" << 'build_libs'
+
+    run( *cmd )
+  end
+end
+
+desc "compile static #{LIBEAY32}"
+file LIBEAY32 => :compile_static_openssl do |t|
+  FileUtils.cp( STATIC_OPENSSL_BUILDDIR + 'libcrypto.a', LIBEAY32.to_s )
+end
+
+desc "compile static #{LIBSSLEAY32}"
+file LIBSSLEAY32 => :compile_static_openssl do |t|
+  FileUtils.cp( STATIC_OPENSSL_BUILDDIR + 'libssl.a', LIBSSLEAY32.to_s )
+end
+
+
+
+#
+# Static PostgreSQL build tasks
+#
+directory STATIC_POSTGRESQL_BUILDDIR.to_s
+
+
+# postgresql source file should be stored there
+file POSTGRESQL_TARBALL => STATIC_SOURCESDIR do |t|
+  download( POSTGRESQL_SOURCE_URI, t.name )
+end
+
+# Extract the postgresql sources
+file STATIC_POSTGRESQL_BUILDDIR => POSTGRESQL_TARBALL do |t|
+  puts "extracting %s to %s" % [ POSTGRESQL_TARBALL, STATIC_POSTGRESQL_BUILDDIR.parent ]
+  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
+end
+
+# generate the makefile in a clean build location
+file POSTGRESQL_GLOBAL_MAKEFILE => [ STATIC_POSTGRESQL_BUILDDIR, :openssl_libs ] do |t|
+  options = [
+    '--target=i386-mingw32',
+    "--host=#{Rake::ExtensionCompiler.mingw_host}",
+    '--with-openssl',
+    '--without-zlib',
+    '--disable-shared',
+  ]
+
+  Dir.chdir( STATIC_POSTGRESQL_BUILDDIR ) do
+    configure_path = STATIC_POSTGRESQL_BUILDDIR + 'configure'
+    cmd = [ configure_path.to_s, *options ]
+    cmd << "CFLAGS=-L#{STATIC_OPENSSL_BUILDDIR}"
+    cmd << "LDFLAGS=-L#{STATIC_OPENSSL_BUILDDIR}"
+    cmd << "LDFLAGS_SL=-L#{STATIC_OPENSSL_BUILDDIR}"
+    cmd << "LIBS=-lwsock32 -lws2_32 -lgdi32"
+    cmd << "CPPFLAGS=-I#{STATIC_OPENSSL_BUILDDIR}/include"
+
+    run( *cmd )
+  end
+end
+
+
+# patch the Makefile.shlib -- depend on the build dir so it's only
+# rewritten if the tarball is re-extracted.
+file POSTGRESQL_SHLIB_MAKEFILE => POSTGRESQL_SHLIB_MF_ORIG do |t|
+  tf = Tempfile.new( POSTGRESQL_SHLIB_MAKEFILE.basename )
+  POSTGRESQL_SHLIB_MF_ORIG.open( File::RDONLY ) do |ifh|
+    ifh.each_line do |line|
+      tf.print( line.sub(/^(\s*haslibarule\s*=\s*yes)/, "# \\1 ") )
+    end
+  end
+  tf.close
+
+  FileUtils.mv( tf.path, t.name, :verbose => $puts )
+end
+
+
+# make libpq.a
+task POSTGRESQL_LIB => [ POSTGRESQL_GLOBAL_MAKEFILE, POSTGRESQL_SHLIB_MAKEFILE ] do |t|
+  Dir.chdir( POSTGRESQL_LIB.dirname ) do
+    sh 'make', "-j#{NUM_CPUS}", POSTGRESQL_LIB.basename.to_s, 'PORTNAME=win32'
+  end
+end
+
+
+#desc 'compile static libpg.a'
+task :static_libpq => POSTGRESQL_LIB
+
+desc 'cross compile pg for win32'
+task :cross do
+  ENV['CROSS_COMPILING'] = 'yes'
+end
+task :cross => [ :mingw32, :static_libpq ]
+
+task :mingw32 do
+  # Use Rake::ExtensionCompiler helpers to find the proper host
+  unless Rake::ExtensionCompiler.mingw_host then
+    warn "You need to install mingw32 cross compile functionality to be able to continue."
+    warn "Please refer to your distribution/package manager documentation about installation."
+    fail
+  end
+end

data/ext/compat.c

@@ -8,8 +8,8 @@
   Author: ematsu
   modified at: Wed Jan 20 16:41:51 1999
 
-  $Author: ged $
-  $Date: 2010/10/31 23:29:59 $
+  $Author$
+  $Date$
 ************************************************/
 
 #include <ctype.h>

data/ext/extconf.rb

@@ -2,6 +2,11 @@ require 'pp'
 require 'mkmf'
 
 
+if ENV['MAINTAINER_MODE']
+	$stderr.puts "Maintainer mode enabled."
+	$CFLAGS << ' -Wall' << ' -ggdb' << ' -DDEBUG'
+end
+
 if pgdir = with_config( 'pg' )
 	ENV['PATH'] = "#{pgdir}/bin" + File::PATH_SEPARATOR + ENV['PATH']
 end
@@ -21,8 +26,8 @@ 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 ]
+	$CPPFLAGS << " -I%s" % [ `"#{pgconfig}" --includedir`.chomp ]
+	$LDFLAGS << " -L%s" % [ `"#{pgconfig}" --libdir`.chomp ]
 else
 	$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
 		" --with-pg-config=/path/to/pg_config"
@@ -48,6 +53,9 @@ have_func 'lo_create'
 have_func 'pg_encoding_to_char'
 have_func 'PQsetClientEncoding'
 
+have_func 'rb_encdb_alias'
+have_func 'rb_enc_alias'
+
 $defs.push( "-DHAVE_ST_NOTIFY_EXTRA" ) if
 	have_struct_member 'struct pgNotify', 'extra', 'libpq-fe.h'
 

data/ext/pg.c

@@ -8,8 +8,8 @@
   Author: ematsu
   modified at: Wed Jan 20 16:41:51 1999
 
-  $Author: ged $
-  $Date: 2011/04/18 23:51:05 $
+  $Author$
+  $Date$
 ************************************************/
 
 #include "pg.h"
@@ -28,7 +28,7 @@ static VALUE rb_cPGconn;
 static VALUE rb_cPGresult;
 static VALUE rb_ePGError;
 
-static const char *VERSION = "0.11.0";
+static const char *VERSION = "0.12.0";
 
 
 /* The following functions are part of libpq, but not
@@ -293,7 +293,7 @@ pgconn_alloc(VALUE klass)
  * If the Ruby default internal encoding is set (i.e., Encoding.default_internal != nil), the
  * connection will have its +client_encoding+ set accordingly.
  * 
- * @raises [PGError] if the connection fails.
+ * Raises a PGError if the connection fails.
  */
 static VALUE
 pgconn_init(int argc, VALUE *argv, VALUE self)
@@ -784,7 +784,7 @@ pgconn_server_version(VALUE self)
 
 /*
  * call-seq:
- *    conn.error() -> String
+ *    conn.error_message -> String
  *
  * Returns the error message about connection.
  */
@@ -1285,7 +1285,6 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
 /*
  * call-seq:
  *    conn.escape_string( str ) -> String
- *    PGconn.escape_string( str ) -> String  # DEPRECATED
  *
  * Connection instance method for versions of 8.1 and higher of libpq
  * uses PQescapeStringConn, which is safer. Avoid calling as a class method,
@@ -1343,7 +1342,6 @@ pgconn_s_escape(VALUE self, VALUE string)
 /*
  * call-seq:
  *   conn.escape_bytea( string ) -> String 
- *   PGconn.escape_bytea( string ) -> String # DEPRECATED
  *
  * Connection instance method for versions of 8.1 and higher of libpq
  * uses PQescapeByteaConn, which is safer. Avoid calling as a class method,
@@ -2056,6 +2054,7 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
  * call-seq:
  *    conn.wait_for_notify( [ timeout ] ) -> String
  *    conn.wait_for_notify( [ timeout ] ) { |event, pid| block }
+ *    conn.wait_for_notify( [ timeout ] ) { |event, pid, payload| block } # PostgreSQL 9.0
  *
  * Blocks while waiting for notification(s), or until the optional
  * _timeout_ is reached, whichever comes first.  _timeout_ is
@@ -2065,6 +2064,10 @@ void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
  * 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)
@@ -2075,7 +2078,7 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 	int ret;
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
-	VALUE timeout_in, relname = Qnil, be_pid = Qnil, extra = Qnil;
+	VALUE timeout_in = Qnil, relname = Qnil, be_pid = Qnil, extra = Qnil;
 	double timeout_sec;
 	fd_set sd_rset;
 #ifdef _WIN32
@@ -2085,7 +2088,9 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 	if ( sd < 0 )
 		rb_bug( "PQsocket(conn): couldn't fetch the connection's socket!" );
 
-	if ( rb_scan_args(argc, argv, "01", &timeout_in) == 1 ) {
+	rb_scan_args( argc, argv, "01", &timeout_in );
+
+	if ( RTEST(timeout_in) ) {
 		timeout_sec = NUM2DBL( timeout_in );
 		timeout.tv_sec = (long)timeout_sec;
 		timeout.tv_usec = (long)( (timeout_sec - (long)timeout_sec) * 1e6 );
@@ -2120,9 +2125,13 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 	}
 
 	relname = rb_tainted_str_new2( notification->relname );
+	ASSOCIATE_INDEX( relname, self );
 	be_pid = INT2NUM( notification->be_pid );
 #ifdef HAVE_ST_NOTIFY_EXTRA
-	extra = rb_str_new2( notification->extra );
+	if ( *notification->extra ) {
+		extra = rb_tainted_str_new2( notification->extra );
+		ASSOCIATE_INDEX( extra, self );
+	}
 #endif
 	PQfreemem( notification );
 
@@ -2483,6 +2492,7 @@ pgconn_transaction(VALUE self)
 	return Qnil;
 }
 
+
 /*
  * call-seq:
  *    PGconn.quote_ident( str ) -> String
@@ -2532,6 +2542,8 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
 }
 
 
+#ifndef _WIN32
+
 /*
  * call-seq:
  *    conn.block( [ timeout ] ) -> Boolean
@@ -2547,27 +2559,152 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
  */
 static VALUE
 pgconn_block( int argc, VALUE *argv, VALUE self ) {
-	PGconn *conn = get_pgconn(self);
-	int sd = PQsocket(conn);
+	PGconn *conn = get_pgconn( self );
+	int sd = PQsocket( conn );
 	int ret;
+
+	/* 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 = (long)timeout_sec;
+		timeout.tv_usec = (long)((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, 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, PQerrorMessage(conn) );
+	}
+
+	return Qtrue;
+}
+
+
+#else /* _WIN32 */
+
+/*
+ * Win32 PGconn#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 = 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 = get_pgconn( self );
+	int sd = PQsocket( conn );
+	int ret;
+
+	struct timeval timeout;
+	struct timeval *ptimeout = NULL;
 	fd_set sd_rset;
-#ifdef _WIN32
 	fd_set crt_sd_rset;
-#endif
+	VALUE timeout_in;
+	double timeout_sec;
 
-	/* Always set a timeout in WIN32, as rb_thread_select() sometimes
+	/* 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.
 	 */
-#if defined(_WIN32)
 	timeout.tv_sec = 0;
-	timeout.tv_usec = 10000;
+	timeout.tv_usec = 10000; // 10ms
 	ptimeout = &timeout;
-#endif
 
 	if ( rb_scan_args(argc, argv, "01", &timeout_in) == 1 ) {
 		timeout_sec = NUM2DBL( timeout_in );
@@ -2576,32 +2713,33 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
 		ptimeout = &timeout;
 	}
 
-	PQconsumeInput( conn );
+	/* Check for connection errors (PQisBusy is true on connection errors) */
+	if( PQconsumeInput(conn) == 0 )
+		rb_raise( rb_ePGError, PQerrorMessage(conn) );
 
 	while ( PQisBusy(conn) ) {
 		FD_ZERO( &sd_rset );
 		FD_SET( sd, &sd_rset );
 
-#ifdef _WIN32
-		create_crt_fd(&sd_rset, &crt_sd_rset);
-#endif
-
-		ret = rb_thread_select (sd+1, &sd_rset, NULL, NULL, ptimeout );
-
-#ifdef _WIN32
-		cleanup_crt_fd(&sd_rset, &crt_sd_rset);
-#endif
+		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 ) 
+		if ( ret == 0 && argc )
 			return Qfalse;
 
-		PQconsumeInput( conn );
-	} 
+		/* Check for connection errors (PQisBusy is true on connection errors) */
+		if ( PQconsumeInput(conn) == 0 )
+			rb_raise( rb_ePGError, PQerrorMessage(conn) );
+	}
 
 	return Qtrue;
 }
 
+#endif /* Ruby 1.9 */
+#endif /* Win32 */
+
 
 /*
  * call-seq:
@@ -2663,6 +2801,7 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 	VALUE rb_pgresult = Qnil;
 
 	/* remove any remaining results from the queue */
+	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
 	pgconn_get_last_result( self );
 
 	pgconn_send_query( argc, argv, self );
@@ -3033,12 +3172,12 @@ pgresult_res_status(VALUE self, VALUE status)
 
 /*
  * call-seq:
- *    res.result_error_message() -> String
+ *    res.error_message() -> String
  *
  * Returns the error message of the command as a string. 
  */
 static VALUE
-pgresult_result_error_message(VALUE self)
+pgresult_error_message(VALUE self)
 {
 	VALUE ret = rb_tainted_str_new2(PQresultErrorMessage(get_pgresult(self)));
 	ASSOCIATE_INDEX(ret, self);
@@ -3047,7 +3186,7 @@ pgresult_result_error_message(VALUE self)
 
 /*
  * call-seq:
- *    res.result_error_field(fieldcode) -> String
+ *    res.error_field(fieldcode) -> String
  *
  * Returns the individual field of an error.
  *
@@ -3064,14 +3203,46 @@ pgresult_result_error_message(VALUE self)
  * * +PG_DIAG_SOURCE_FILE+
  * * +PG_DIAG_SOURCE_LINE+
  * * +PG_DIAG_SOURCE_FUNCTION+
+ *
+ * An example:
+ * 
+ *   begin
+ *       conn.exec( "SELECT * FROM nonexistant_table" )
+ *   rescue PGError => err
+ *       p [
+ *           result.error_field( PGresult::PG_DIAG_SEVERITY ),
+ *           result.error_field( PGresult::PG_DIAG_SQLSTATE ),
+ *           result.error_field( PGresult::PG_DIAG_MESSAGE_PRIMARY ),
+ *           result.error_field( PGresult::PG_DIAG_MESSAGE_DETAIL ),
+ *           result.error_field( PGresult::PG_DIAG_MESSAGE_HINT ),
+ *           result.error_field( PGresult::PG_DIAG_STATEMENT_POSITION ),
+ *           result.error_field( PGresult::PG_DIAG_INTERNAL_POSITION ),
+ *           result.error_field( PGresult::PG_DIAG_INTERNAL_QUERY ),
+ *           result.error_field( PGresult::PG_DIAG_CONTEXT ),
+ *           result.error_field( PGresult::PG_DIAG_SOURCE_FILE ),
+ *           result.error_field( PGresult::PG_DIAG_SOURCE_LINE ),
+ *           result.error_field( PGresult::PG_DIAG_SOURCE_FUNCTION ),
+ *       ]
+ *   end
+ * 
+ * Outputs:
+ * 
+ *   ["ERROR", "42P01", "relation \"nonexistant_table\" does not exist", nil, nil, 
+ *    "15", nil, nil, nil, "path/to/parse_relation.c", "857", "parserOpenTable"]
  */
 static VALUE
-pgresult_result_error_field(VALUE self, VALUE field)
+pgresult_error_field(VALUE self, VALUE field)
 {
-	PGresult *result = get_pgresult(self);
-	int fieldcode = NUM2INT(field);
-	VALUE ret = rb_tainted_str_new2(PQresultErrorField(result,fieldcode));
-	ASSOCIATE_INDEX(ret, self);
+	PGresult *result = get_pgresult( self );
+	int fieldcode = NUM2INT( field );
+	char * fieldstr = PQresultErrorField( result, fieldcode );
+	VALUE ret = Qnil;
+
+	if ( fieldstr ) {
+		ret = rb_tainted_str_new2( fieldstr );
+		ASSOCIATE_INDEX( ret, self );
+	}
+
 	return ret;
 }
 
@@ -3744,7 +3915,15 @@ static int enc_get_index(VALUE val)
 	return i;
 }
 
+#ifdef HAVE_RB_ENCDB_ALIAS
+#	define ENC_ALIAS(name, orig) rb_encdb_alias((name), (orig))
+#elif HAVE_RB_ENC_ALIAS
+#	define ENC_ALIAS(name, orig) rb_enc_alias((name), (orig))
+#else
 extern int rb_enc_alias(const char *alias, const char *orig); /* declaration missing in Ruby 1.9.1 */
+#	define ENC_ALIAS(name, orig) rb_enc_alias((name), (orig))
+#endif
+
 static rb_encoding *
 find_or_create_johab(void)
 {
@@ -3758,7 +3937,7 @@ find_or_create_johab(void)
 
 	enc_index = rb_define_dummy_encoding(aliases[0]);
 	for (i = 1; i < sizeof(aliases)/sizeof(aliases[0]); ++i) {
-		rb_enc_alias(aliases[i], aliases[0]);
+		ENC_ALIAS(aliases[i], aliases[0]);
 	}
 	return rb_enc_from_index(enc_index);
 }
@@ -4004,7 +4183,6 @@ Init_pg_ext()
 	rb_define_singleton_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
 	rb_define_singleton_method(rb_cPGconn, "connect_start", pgconn_s_connect_start, -1);
 	rb_define_singleton_method(rb_cPGconn, "conndefaults", pgconn_s_conndefaults, 0);
-	
 
 	/******     PGconn CLASS CONSTANTS: Connection Status     ******/
 
@@ -4286,8 +4464,10 @@ Init_pg_ext()
 	/******     PGresult 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, "result_error_message", pgresult_result_error_message, 0);
-	rb_define_method(rb_cPGresult, "result_error_field", pgresult_result_error_field, 1);
+	rb_define_method(rb_cPGresult, "error_message", pgresult_error_message, 0);
+	rb_define_alias( rb_cPGresult, "result_error_message", "error_message");
+	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", pgresult_clear, 0);
 	rb_define_method(rb_cPGresult, "ntuples", pgresult_ntuples, 0);
 	rb_define_alias(rb_cPGresult, "num_tuples", "ntuples");