pg 0.15.1-x64-mingw32 → 0.16.0-x64-mingw32

data/ext/extconf.rb

@@ -27,17 +27,22 @@ if ENV['CROSS_COMPILING']
 	have_library( 'ssl', 'SSL_new' ) && append_library( $libs, 'ssl' )
 end
 
-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 ]
-
+	incdir = `"#{pgconfig}" --includedir`.chomp
 	libdir = `"#{pgconfig}" --libdir`.chomp
-	$LDFLAGS << " -L%s -Wl,-rpath,%s" % [ libdir, libdir ]
+	dir_config 'pg', incdir, libdir
+
+	# Try to use runtime path linker option, even if RbConfig doesn't know about it.
+	# The rpath option is usually set implicit by dir_config(), but so far not
+	# on MacOS-X.
+	if RbConfig::CONFIG["RPATHFLAG"].to_s.empty? && try_link('int main() {return 0;}', " -Wl,-rpath,#{libdir}")
+		$LDFLAGS << " -Wl,-rpath,#{libdir}"
+	end
 else
 	$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
 		" --with-pg-config=/path/to/pg_config"
+	dir_config 'pg'
 end
 
 find_header( 'libpq-fe.h' ) or abort "Can't find the 'libpq-fe.h header"
@@ -78,6 +83,7 @@ have_func 'rb_w32_wrap_io_handle'
 
 have_const 'PGRES_COPY_BOTH', 'libpq-fe.h'
 have_const 'PGRES_SINGLE_TUPLE', 'libpq-fe.h'
+have_const 'PG_DIAG_TABLE_NAME', 'libpq-fe.h'
 
 $defs.push( "-DHAVE_ST_NOTIFY_EXTRA" ) if
 	have_struct_member 'struct pgNotify', 'extra', 'libpq-fe.h'

data/ext/gvl_wrappers.c

@@ -11,3 +11,9 @@ 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 );
+
+void ubf_cancel_running_command(void *c)
+{
+	PGconn *conn = (PGconn*) c;
+	PQrequestCancel(conn);
+}

data/ext/gvl_wrappers.h

@@ -24,6 +24,8 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 				 rb_unblock_function_t *ubf, void *data2);
 #endif
 
+void ubf_cancel_running_command(void *c);
+
 #define DEFINE_PARAM_LIST1(type, name) \
 	name,
 
@@ -36,7 +38,7 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 #define DEFINE_PARAM_DECL(type, name) \
 	type name;
 
-#define DEFINE_GVL_WRAPPER_STRUCT(name, when_non_void, rettype, lastparamtype, lastparamname) \
+#define DEFINE_GVL_WRAPPER_STRUCT(name, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
 	struct gvl_wrapper_##name##_params { \
 		struct { \
 			FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_DECL) \
@@ -45,7 +47,7 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 		when_non_void( rettype retval; ) \
 	};
 
-#define DEFINE_GVL_SKELETON(name, when_non_void, rettype, lastparamtype, lastparamname) \
+#define DEFINE_GVL_SKELETON(name, cancel_params, 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 = ) \
@@ -54,25 +56,25 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 	}
 
 #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-	#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	#define DEFINE_GVL_STUB(name, cancel_params, 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); \
+			rb_thread_call_without_gvl(gvl_##name##_skeleton, &params, cancel_params); \
 			when_non_void( return params.retval; ) \
 		}
 #else
-	#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	#define DEFINE_GVL_STUB(name, cancel_params, 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) \
+#define DEFINE_GVL_STUB_DECL(name, cancel_params, 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) \
+#define DEFINE_GVLCB_SKELETON(name, cancel_params, 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 = ) \
@@ -81,7 +83,7 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 	}
 
 #if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
-	#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	#define DEFINE_GVLCB_STUB(name, cancel_params, 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) \
@@ -90,7 +92,7 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 			when_non_void( return params.retval; ) \
 		}
 #else
-	#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	#define DEFINE_GVLCB_STUB(name, cancel_params, 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 ); \
 		}
@@ -99,11 +101,26 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 #define GVL_TYPE_VOID(string)
 #define GVL_TYPE_NONVOID(string) string
 
+#define GVL_CANCELABLE ubf_cancel_running_command, conn
+#define GVL_NONCANCELABLE RUBY_UBF_IO, 0
+
 
 /*
  * Definitions of blocking functions and their parameters
  */
 
+#define FOR_EACH_PARAM_OF_PQconnectdb(param)
+
+#define FOR_EACH_PARAM_OF_PQconnectStart(param)
+
+#define FOR_EACH_PARAM_OF_PQconnectPoll(param)
+
+#define FOR_EACH_PARAM_OF_PQreset(param)
+
+#define FOR_EACH_PARAM_OF_PQresetStart(param)
+
+#define FOR_EACH_PARAM_OF_PQresetPoll(param)
+
 #define FOR_EACH_PARAM_OF_PQexec(param) \
 	param(PGconn *, conn)
 
@@ -149,18 +166,27 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 	param(PGconn *, conn) \
 	param(char **, buffer)
 
+#define FOR_EACH_PARAM_OF_PQnotifies(param)
+
 /* 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) \
+	function(PQconnectdb, GVL_NONCANCELABLE, GVL_TYPE_NONVOID, PGconn *, const char *, conninfo) \
+	function(PQconnectStart, GVL_NONCANCELABLE, GVL_TYPE_NONVOID, PGconn *, const char *, conninfo) \
+	function(PQconnectPoll, GVL_CANCELABLE, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	function(PQreset, GVL_CANCELABLE, GVL_TYPE_VOID, void, PGconn *, conn) \
+	function(PQresetStart, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQresetPoll, GVL_CANCELABLE, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	function(PQexec, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, const char *, command) \
+	function(PQexecParams, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
+	function(PQexecPrepared, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
+	function(PQprepare, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, const Oid *, paramTypes) \
+	function(PQdescribePrepared, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, const char *, stmtName) \
+	function(PQdescribePortal, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, const char *, portalName) \
+	function(PQgetResult, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGresult *, PGconn *, conn) \
+	function(PQputCopyData, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, int, nbytes) \
+	function(PQputCopyEnd, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, const char *, errormsg) \
+	function(PQgetCopyData, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, int, async) \
+	function(PQnotifies, GVL_CANCELABLE, GVL_TYPE_NONVOID, PGnotify *, PGconn *, conn);
 
 FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
 
@@ -177,8 +203,8 @@ FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
 
 /* 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) \
+	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 );
 

data/ext/pg.c

@@ -48,7 +48,6 @@
 #include "pg.h"
 
 VALUE rb_mPG;
-VALUE rb_ePGerror;
 VALUE rb_mPGconstants;
 
 
@@ -300,7 +299,6 @@ void
 Init_pg_ext()
 {
 	rb_mPG = rb_define_module( "PG" );
-	rb_ePGerror = rb_define_class_under( rb_mPG, "Error", rb_eStandardError );
 	rb_mPGconstants = rb_define_module_under( rb_mPG, "Constants" );
 
 	/*************************
@@ -313,13 +311,6 @@ Init_pg_ext()
 	SINGLETON_ALIAS( rb_mPG, "is_threadsafe?", "isthreadsafe" );
 	SINGLETON_ALIAS( rb_mPG, "threadsafe?", "isthreadsafe" );
 
-	/*************************
-	 *  PG::Error
-	 *************************/
-	rb_define_alias( rb_ePGerror, "error", "message" );
-	rb_define_attr( rb_ePGerror, "connection", 1, 0 );
-	rb_define_attr( rb_ePGerror, "result", 1, 0 );
-
 	/******     PG::Connection CLASS CONSTANTS: Connection Status     ******/
 
 	/* Connection succeeded */
@@ -506,6 +497,34 @@ Init_pg_ext()
 	 * function reporting the error. */
 	rb_define_const(rb_mPGconstants, "PG_DIAG_SOURCE_FUNCTION", INT2FIX(PG_DIAG_SOURCE_FUNCTION));
 
+#ifdef HAVE_CONST_PG_DIAG_TABLE_NAME
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific database object, the name of the schema containing that object, if any. */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_SCHEMA_NAME", INT2FIX(PG_DIAG_SCHEMA_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 *specific table, the name of the table. (When this field is present, the schema name
+	 * field provides the name of the table's schema.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_TABLE_NAME", INT2FIX(PG_DIAG_TABLE_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific table column, the name of the column. (When this field is present, the
+	 * schema and table name fields identify the table.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_COLUMN_NAME", INT2FIX(PG_DIAG_COLUMN_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific datatype, the name of the datatype. (When this field is present, the
+	 * schema name field provides the name of the datatype's schema.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_DATATYPE_NAME", INT2FIX(PG_DIAG_DATATYPE_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific constraint, the name of the constraint. The table or domain that the
+	 * constraint belongs to is reported using the fields listed above. (For this
+	 * purpose, indexes are treated as constraints, even if they weren't created with
+	 * constraint syntax.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_CONSTRAINT_NAME", INT2FIX(PG_DIAG_CONSTRAINT_NAME));
+#endif
+
 	/* Invalid OID constant */
 	rb_define_const(rb_mPGconstants, "INVALID_OID", INT2FIX(InvalidOid));
 	rb_define_const(rb_mPGconstants, "InvalidOid", INT2FIX(InvalidOid));
@@ -521,5 +540,6 @@ Init_pg_ext()
 	/* Initialize the main extension classes */
 	init_pg_connection();
 	init_pg_result();
+	init_pg_errors();
 }
 

data/ext/pg.h

@@ -66,6 +66,30 @@
 #	include "ruby/io.h"
 #endif
 
+#ifndef timeradd
+#define timeradd(a, b, result) \
+	do { \
+		(result)->tv_sec = (a)->tv_sec + (b)->tv_sec; \
+		(result)->tv_usec = (a)->tv_usec + (b)->tv_usec; \
+		if ((result)->tv_usec >= 1000000L) { \
+			++(result)->tv_sec; \
+			(result)->tv_usec -= 1000000L; \
+		} \
+	} while (0)
+#endif
+
+#ifndef timersub
+#define timersub(a, b, result) \
+	do { \
+		(result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \
+		(result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \
+		if ((result)->tv_usec < 0) { \
+			--(result)->tv_sec; \
+			(result)->tv_usec += 1000000L; \
+		} \
+	} while (0)
+#endif
+
 /* PostgreSQL headers */
 #include "libpq-fe.h"
 #include "libpq/libpq-fs.h"              /* large-object interface */
@@ -85,9 +109,13 @@ typedef long suseconds_t;
 
 extern VALUE rb_mPG;
 extern VALUE rb_ePGerror;
+extern VALUE rb_eServerError;
+extern VALUE rb_eUnableToSend;
+extern VALUE rb_eConnectionBad;
 extern VALUE rb_mPGconstants;
 extern VALUE rb_cPGconn;
 extern VALUE rb_cPGresult;
+extern VALUE rb_hErrors;
 
 
 /***************************************************************************
@@ -105,6 +133,8 @@ void Init_pg_ext                                       _(( void ));
 
 void init_pg_connection                                _(( void ));
 void init_pg_result                                    _(( void ));
+void init_pg_errors                                    _(( void ));
+VALUE lookup_error_class                               _(( const char *sqlstate ));
 
 PGconn *pg_get_pgconn	                               _(( VALUE ));
 

data/ext/pg_connection.c

@@ -40,7 +40,7 @@ pg_get_pgconn( VALUE self )
 	PGconn *conn = pgconn_check( self );
 
 	if ( !conn )
-		rb_raise( rb_ePGerror, "connection is closed" );
+		rb_raise( rb_eConnectionBad, "connection is closed" );
 
 	return conn;
 }
@@ -58,7 +58,7 @@ pgconn_close_socket_io( VALUE self )
 #if defined(_WIN32) && defined(HAVE_RB_W32_WRAP_IO_HANDLE)
 		int ruby_sd = NUM2INT(rb_funcall( socket_io, rb_intern("fileno"), 0 ));
 		if( rb_w32_unwrap_io_handle(ruby_sd) ){
-			rb_raise(rb_ePGerror, "Could not unwrap win32 socket handle");
+			rb_raise(rb_eConnectionBad, "Could not unwrap win32 socket handle");
 		}
 #endif
 		rb_funcall( socket_io, rb_intern("close"), 0 );
@@ -113,7 +113,11 @@ pgconn_gc_free( PGconn *conn )
 static VALUE
 pgconn_s_allocate( VALUE klass )
 {
-	return Data_Wrap_Struct( klass, NULL, pgconn_gc_free, NULL );
+	VALUE self = Data_Wrap_Struct( klass, NULL, pgconn_gc_free, NULL );
+	rb_iv_set( self, "@socket_io", Qnil );
+	rb_iv_set( self, "@notice_receiver", Qnil);
+	rb_iv_set( self, "@notice_processor", Qnil);
+	return self;
 }
 
 
@@ -182,16 +186,16 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 	VALUE error;
 
 	conninfo = rb_funcall2( rb_cPGconn, rb_intern("parse_connect_args"), argc, argv );
-	conn = PQconnectdb(StringValuePtr(conninfo));
+	conn = gvl_PQconnectdb(StringValuePtr(conninfo));
 
 	if(conn == NULL)
-		rb_raise(rb_ePGerror, "PQconnectStart() unable to allocate structure");
+		rb_raise(rb_ePGerror, "PQconnectdb() unable to allocate structure");
 
 	Check_Type(self, T_DATA);
 	DATA_PTR(self) = conn;
 
 	if (PQstatus(conn) == CONNECTION_BAD) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eConnectionBad, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -236,7 +240,7 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	 */
 	rb_conn  = pgconn_s_allocate( klass );
 	conninfo = rb_funcall2( klass, rb_intern("parse_connect_args"), argc, argv );
-	conn     = PQconnectStart( StringValuePtr(conninfo) );
+	conn     = gvl_PQconnectStart( StringValuePtr(conninfo) );
 
 	if( conn == NULL )
 		rb_raise(rb_ePGerror, "PQconnectStart() unable to allocate structure");
@@ -245,7 +249,7 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	DATA_PTR(rb_conn) = conn;
 
 	if ( PQstatus(conn) == CONNECTION_BAD ) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eConnectionBad, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", rb_conn);
 		rb_exc_raise(error);
 	}
@@ -415,7 +419,7 @@ static VALUE
 pgconn_connect_poll(VALUE self)
 {
 	PostgresPollingStatusType status;
-	status = PQconnectPoll(pg_get_pgconn(self));
+	status = gvl_PQconnectPoll(pg_get_pgconn(self));
 	return INT2FIX((int)status);
 }
 
@@ -460,7 +464,7 @@ static VALUE
 pgconn_reset( VALUE self )
 {
 	pgconn_close_socket_io( self );
-	PQreset( pg_get_pgconn(self) );
+	gvl_PQreset( pg_get_pgconn(self) );
 	return self;
 }
 
@@ -478,8 +482,8 @@ static VALUE
 pgconn_reset_start(VALUE self)
 {
 	pgconn_close_socket_io( self );
-	if(PQresetStart(pg_get_pgconn(self)) == 0)
-		rb_raise(rb_ePGerror, "reset has failed");
+	if(gvl_PQresetStart(pg_get_pgconn(self)) == 0)
+		rb_raise(rb_eUnableToSend, "reset has failed");
 	return Qnil;
 }
 
@@ -495,7 +499,7 @@ static VALUE
 pgconn_reset_poll(VALUE self)
 {
 	PostgresPollingStatusType status;
-	status = PQresetPoll(pg_get_pgconn(self));
+	status = gvl_PQresetPoll(pg_get_pgconn(self));
 	return INT2FIX((int)status);
 }
 
@@ -718,7 +722,7 @@ pgconn_socket(VALUE self)
 {
 	int sd;
 	if( (sd = PQsocket(pg_get_pgconn(self))) < 0)
-		rb_raise(rb_ePGerror, "Can't get socket descriptor");
+		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
 	return INT2NUM(sd);
 }
 
@@ -749,7 +753,7 @@ pgconn_socket_io(VALUE self)
 
 	if ( !RTEST(socket_io) ) {
 		if( (sd = PQsocket(pg_get_pgconn(self))) < 0)
-			rb_raise(rb_ePGerror, "Can't get socket descriptor");
+			rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
 
 		#ifdef _WIN32
 			ruby_sd = rb_w32_wrap_io_handle((HANDLE)(intptr_t)sd, O_RDWR|O_BINARY|O_NOINHERIT);
@@ -1448,6 +1452,10 @@ pgconn_escape_literal(VALUE self, VALUE string)
 	PQfreemem(escaped);
 	OBJ_INFECT(result, string);
 
+#ifdef M17N_SUPPORTED
+	rb_enc_associate(result, pg_conn_enc_get( pg_get_pgconn(self) ));
+#endif
+
 	return result;
 }
 #endif
@@ -1458,6 +1466,9 @@ pgconn_escape_literal(VALUE self, VALUE string)
  *    conn.escape_identifier( str ) -> String
  *
  * Escape an arbitrary String +str+ as an identifier.
+ *
+ * This method does the same as #quote_ident, but uses libpq to
+ * process the string.
  */
 static VALUE
 pgconn_escape_identifier(VALUE self, VALUE string)
@@ -1481,6 +1492,10 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 	PQfreemem(escaped);
 	OBJ_INFECT(result, string);
 
+#ifdef M17N_SUPPORTED
+	rb_enc_associate(result, pg_conn_enc_get( pg_get_pgconn(self) ));
+#endif
+
 	return result;
 }
 #endif
@@ -1596,7 +1611,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 	/* If called with no parameters, use PQsendQuery */
 	if(NIL_P(params)) {
 		if(PQsendQuery(conn,StringValuePtr(command)) == 0) {
-			error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+			error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 			rb_iv_set(error, "@connection", self);
 			rb_exc_raise(error);
 		}
@@ -1679,7 +1694,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 	xfree(paramFormats);
 
 	if(result == 0) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -1741,7 +1756,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	xfree(paramTypes);
 
 	if(result == 0) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -1864,7 +1879,7 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 	xfree(paramFormats);
 
 	if(result == 0) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -1885,7 +1900,7 @@ pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 	PGconn *conn = pg_get_pgconn(self);
 	/* returns 0 on failure */
 	if(PQsendDescribePrepared(conn,StringValuePtr(stmt_name)) == 0) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -1907,7 +1922,7 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
 	PGconn *conn = pg_get_pgconn(self);
 	/* returns 0 on failure */
 	if(PQsendDescribePortal(conn,StringValuePtr(portal)) == 0) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -1965,7 +1980,7 @@ pgconn_consume_input(self)
 	PGconn *conn = pg_get_pgconn(self);
 	/* returns 0 on error */
 	if(PQconsumeInput(conn) == 0) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
+		error = rb_exc_new2(rb_eConnectionBad, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
@@ -2122,7 +2137,7 @@ pgconn_notifies(VALUE self)
 	sym_be_pid = ID2SYM(rb_intern("be_pid"));
 	sym_extra = ID2SYM(rb_intern("extra"));
 
-	notification = PQnotifies(conn);
+	notification = gvl_PQnotifies(conn);
 	if (notification == NULL) {
 		return Qnil;
 	}
@@ -2199,32 +2214,46 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 {
 	int sd = PQsocket( conn );
 	void *retval;
+	struct timeval aborttime={0,0}, currtime, waittime;
 	DWORD timeout_milisec = INFINITE;
 	DWORD wait_ret;
 	WSAEVENT hEvent;
 
 	if ( sd < 0 )
-		rb_bug( "PQsocket(conn): couldn't fetch the connection's socket!" );
+		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
 
 	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) );
+		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
+	}
+
+	if ( ptimeout ) {
+		gettimeofday(&currtime, NULL);
+		timeradd(&currtime, ptimeout, &aborttime);
 	}
 
 	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() );
+			rb_raise( rb_eConnectionBad, "WSAEventSelect socket error: %d", WSAGetLastError() );
 		}
 
-		wait_ret = rb_w32_wait_events( &hEvent, 1, timeout_milisec );
+		if ( ptimeout ) {
+			gettimeofday(&currtime, NULL);
+			timersub(&aborttime, &currtime, &waittime);
+			timeout_milisec = (DWORD)( waittime.tv_sec * 1e3 + waittime.tv_usec / 1e3 );
+		}
+
+		/* Is the given timeout valid? */
+		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
+			/* Wait for the socket to become readable before checking again */
+			wait_ret = rb_w32_wait_events( &hEvent, 1, timeout_milisec );
+		} else {
+			wait_ret = WAIT_TIMEOUT;
+		}
 
 		if ( wait_ret == WAIT_TIMEOUT ) {
 			WSACloseEvent( hEvent );
@@ -2237,16 +2266,16 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 			rb_thread_check_ints();
 		} else if ( wait_ret == WAIT_FAILED ) {
 			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, "Wait on socket error (WaitForMultipleObjects): %lu", GetLastError() );
+			rb_raise( rb_eConnectionBad, "Wait on socket error (WaitForMultipleObjects): %lu", GetLastError() );
 		} else {
 			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, "Wait on socket abandoned (WaitForMultipleObjects)" );
+			rb_raise( rb_eConnectionBad, "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) );
+			rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
 		}
 	}
 
@@ -2265,18 +2294,24 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 	int ret;
 	void *retval;
 	rb_fdset_t sd_rset;
+	struct timeval aborttime={0,0}, currtime, waittime;
 #ifdef _WIN32
 	rb_fdset_t crt_sd_rset;
 #endif
 
 	if ( sd < 0 )
-		rb_bug( "PQsocket(conn): couldn't fetch the connection's socket!" );
+		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
 
 	/* Check for connection errors (PQisBusy is true on connection errors) */
 	if ( PQconsumeInput(conn) == 0 )
-		rb_raise( rb_ePGerror, "%s", PQerrorMessage(conn) );
+		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
+
+	rb_fd_init( &sd_rset );
 
-  rb_fd_init( &sd_rset );
+	if ( ptimeout ) {
+		gettimeofday(&currtime, NULL);
+		timeradd(&currtime, ptimeout, &aborttime);
+	}
 
 	while ( !(retval=is_readable(conn)) ) {
 		rb_fd_zero( &sd_rset );
@@ -2290,8 +2325,19 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 		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 );
+		if ( ptimeout ) {
+			gettimeofday(&currtime, NULL);
+			timersub(&aborttime, &currtime, &waittime);
+		}
+
+		/* Is the given timeout valid? */
+		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
+			/* Wait for the socket to become readable before checking again */
+			ret = rb_thread_fd_select( sd+1, &sd_rset, NULL, NULL, ptimeout ? &waittime : NULL );
+		} else {
+			ret = 0;
+		}
+
 
 #ifdef _WIN32
 		cleanup_crt_fd(&sd_rset, &crt_sd_rset);
@@ -2311,7 +2357,7 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 		/* 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_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
 		}
 	}
 
@@ -2325,7 +2371,7 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 static void *
 notify_readable(PGconn *conn)
 {
-	return (void*)PQnotifies(conn);
+	return (void*)gvl_PQnotifies(conn);
 }
 
 /*
@@ -2761,7 +2807,7 @@ pgconn_set_client_encoding(VALUE self, VALUE str)
 
 /*
  * call-seq:
- *    conn.transaction { |conn| ... } -> nil
+ *    conn.transaction { |conn| ... } -> result of the block
  *
  * Executes a +BEGIN+ at the start of the block,
  * and a +COMMIT+ at the end of the block, or
@@ -2773,13 +2819,14 @@ pgconn_transaction(VALUE self)
 	PGconn *conn = pg_get_pgconn(self);
 	PGresult *result;
 	VALUE rb_pgresult;
+	VALUE block_result = Qnil;
 	int status;
 
 	if (rb_block_given_p()) {
 		result = gvl_PQexec(conn, "BEGIN");
 		rb_pgresult = pg_new_result(result, self);
 		pg_result_check(rb_pgresult);
-		rb_protect(rb_yield, self, &status);
+		block_result = rb_protect(rb_yield, self, &status);
 		if(status == 0) {
 			result = gvl_PQexec(conn, "COMMIT");
 			rb_pgresult = pg_new_result(result, self);
@@ -2798,7 +2845,7 @@ pgconn_transaction(VALUE self)
 		/* no block supplied? */
 		rb_raise(rb_eArgError, "Must supply block for PG::Connection#transaction");
 	}
-	return Qnil;
+	return block_result;
 }
 
 
@@ -2832,6 +2879,9 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
 	 * double-quotes. */
 	char buffer[NAMEDATALEN*2+2];
 	unsigned int i=0,j=0;
+#ifdef M17N_SUPPORTED
+	rb_encoding* enc;
+#endif
 
 	UNUSED( self );
 
@@ -2849,6 +2899,16 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
 	buffer[j++] = '"';
 	ret = rb_str_new(buffer,j);
 	OBJ_INFECT(ret, in_str);
+
+#ifdef M17N_SUPPORTED
+	if ( rb_obj_class(self) == rb_cPGconn ) {
+		enc = pg_conn_enc_get( pg_get_pgconn(self) );
+	} else {
+		enc = rb_enc_get(in_str);
+	}
+	rb_enc_associate(ret, enc);
+#endif
+
 	return ret;
 }