pg 0.17.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 82f24c3c723c5c426929fd7c14b784f8db43fccc
-  data.tar.gz: 3ce6e0d944af02a3283c2d51588e988df89da216
+  metadata.gz: 76e0a053a21b6714395f5ccf1bd43c9caa235584
+  data.tar.gz: 6d1021ba6991c151049c33f0963f22c5c1262a75
 SHA512:
-  metadata.gz: eb683af0ecf1711e19a5e497e63d7ca5fe08180db99b373fdbd9e0167d3930bfb55de6fe37f116a0e8d3c520741bef019ebcc15993da905eceb495c03ec23c31
-  data.tar.gz: e7255b4ce2802d0b97b4af8fe3a5715bfbffc2aee7d454b1c6bd6eec8b82aa711212467ca0b99a6614355b8ad1f101b9075f443b88d36e648aa0251848923b3f
+  metadata.gz: 3b91c230861ffd1e08fd835ce16245f9abe9344f435f558fbd8987cf6db81255473445a0ea7c1cbb8f602f2eb6bd2ea1ac446cfba484939bb9635ba67ef4060b
+  data.tar.gz: 3219c6f4aaebb9ba597e1ae772b74edb19e27b80f1f60c16537a85f4790e427d040ebfdd46d8e44a626994a5599cdbf9fc82ce3ab269c5f3b7b77b5a80fccc3c

data.tar.gz.sig

@@ -1,2 +1 @@
-2+��Ѣ���"����M�5��c&��X���A�I�9�\�7xhn�4G�1=(�0R�)#O���#z …S`|,�\$�\�\�K�ԓ�G
-|7^`�^6�ui��&�ه^(K���E�;R�ZO1V�>�g�L4=�ZL���Zřw�[�\7h�B���)l/��J;F�X�V�"�+Py\�Ė&�g��b&<Qj8.Ū��SY
+��8�2vp��֜W
��j�х��"a�GiN�

data/ChangeLog

@@ -1,8 +1,83 @@
+2013-12-17  Lars Kanis  <kanis@comcard.de>
+
+	* History.rdoc:
+	Update History file
+	[ebd0e140f78d] [tip]
+
+2013-12-16  larskanis  <lars@greiz-reinsdorf.de>
+
+	* Close branch revert_query_cancel_on_ubf
+	[cddad8917d19] <revert_query_cancel_on_ubf>
+
+	* Merged in larskanis/ruby-pg/revert_query_cancel_on_ubf (pull request
+	#18)
+
+	Revert commit e0492d4 "Ensure a query is canceled, if a thread is
+	about to be killed."
+	[93a8aedecd05]
+
+2013-12-09  Lars Kanis  <kanis@comcard.de>
+
+	* spec/pg/connection_spec.rb:
+	Add test case for compatibility with signal handlers. See 97c3ec2.
+	[1e974a370012] <revert_query_cancel_on_ubf>
+
+	* ext/gvl_wrappers.c, ext/gvl_wrappers.h, ext/pg_connection.c,
+	spec/pg/connection_spec.rb:
+	Revert commit e0492d4 "Ensure a query is canceled, if a thread is
+	about to be killed."
+
+	This is due to this discussion: https://groups.google.com/d/topic
+	/ruby-pg/5_ylGmog1S4/discussion
+
+	We were using rb_thread_call_without_gvl() with an ubf which
+	canceled the query currently being processed. This turned out to be
+	incompatible with possibly registered signal handlers (by
+	Signal.trap). A ubf is unconditionally invoked if ANY signal fires
+	on a process (eg even: USR1 or PROF) and Ruby has handlers
+	registered. Cancelling queries in those conditions does no make
+	sense.
+
+	This commit re-enables Connection#async_exec based on the async API
+	for all ruby versions, because async_exec allowes cancelation of
+	queries by signals like Control+C.
+
+	Thanks to Sam Saffron for highlighting this issue.
+	[97c3ec224be9] <revert_query_cancel_on_ubf>
+
+2013-09-23  Michael Granger  <ged@FaerieMUD.org>
+
+	* ext/pg_connection.c, lib/pg/connection.rb:
+	Fix documentation for PG::Connection::conndefaults.
+	[9812218e0654] [github/master]
+
+2013-09-20  Lars Kanis  <lars@greiz-reinsdorf.de>
+
+	* ext/gvl_wrappers.h, ext/pg_connection.c:
+	Wrap PQcancel to be called without GVL. It internally waits for
+	close of the connection to be canceled.
+	[0ed6451d10a5]
+
+2013-09-16  Michael Granger  <ged@FaerieMUD.org>
+
+	* .hgtags:
+	Added tag v0.17.0 for changeset 30da9c169efc
+	[46f35f5b396e]
+
+	* .hgsigs:
+	Added signature for changeset eed93df350a6
+	[30da9c169efc] [v0.17.0]
+
+	* .hoerc:
+	Add the Gemfile to the list of files that don't have to be on the
+	Manifest.
+	[eed93df350a6]
+
 2013-09-15  Michael Granger  <ged@FaerieMUD.org>
 
 	* History.rdoc, lib/pg.rb:
 	Bump minor version
-	[7cdff0a462e5] [tip]
+	[7cdff0a462e5]
 
 2013-09-14  Lars Kanis  <lars@greiz-reinsdorf.de>
 
@@ -79,7 +154,7 @@
 	compilation platform.
 
 	This is 'i586-mingw32msvc-gcc' versus 'i586-pc-mingw32msvc'.
-	[fbee9586e8f7] [github/master]
+	[fbee9586e8f7]
 
 2013-08-14  Lars Kanis  <lars@greiz-reinsdorf.de>
 

data/History.rdoc

@@ -1,3 +1,19 @@
+== v0.17.1 [2013-12-18] Michael Granger <ged@FaerieMUD.org>
+
+Bugfixes:
+
+- Fix compatibility with signal handlers defined in Ruby. This reverts
+  cancelation of queries running on top of the blocking libpq API (like
+  Connection#exec) in case of signals. As an alternative the #async_exec
+  can be used, which is reverted to use the non-blocking API, again.
+- Wrap PQcancel to be called without GVL. It internally waits for
+  the canceling connection.
+
+Documentation fixes:
+
+- Fix documentation for PG::Connection::conndefaults.
+
+
 == v0.17.0 [2013-09-15] Michael Granger <ged@FaerieMUD.org>
 
 Bugfixes:

data/ext/gvl_wrappers.c

@@ -11,9 +11,3 @@ 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,8 +24,6 @@ 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,
 
@@ -38,7 +36,7 @@ void ubf_cancel_running_command(void *c);
 #define DEFINE_PARAM_DECL(type, name) \
 	type name;
 
-#define DEFINE_GVL_WRAPPER_STRUCT(name, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+#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) \
@@ -47,7 +45,7 @@ void ubf_cancel_running_command(void *c);
 		when_non_void( rettype retval; ) \
 	};
 
-#define DEFINE_GVL_SKELETON(name, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+#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 = ) \
@@ -56,25 +54,25 @@ void ubf_cancel_running_command(void *c);
 	}
 
 #if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-	#define DEFINE_GVL_STUB(name, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+	#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, cancel_params); \
+			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, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+	#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, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+#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, cancel_params, when_non_void, rettype, 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 = ) \
@@ -83,7 +81,7 @@ void ubf_cancel_running_command(void *c);
 	}
 
 #if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
-	#define DEFINE_GVLCB_STUB(name, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+	#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) \
@@ -92,7 +90,7 @@ void ubf_cancel_running_command(void *c);
 			when_non_void( return params.retval; ) \
 		}
 #else
-	#define DEFINE_GVLCB_STUB(name, cancel_params, when_non_void, rettype, lastparamtype, lastparamname) \
+	#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 ); \
 		}
@@ -101,9 +99,6 @@ void ubf_cancel_running_command(void *c);
 #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
@@ -202,32 +197,37 @@ void ubf_cancel_running_command(void *c);
 
 #define FOR_EACH_PARAM_OF_PQisBusy(param)
 
-/* function( name, cancel, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
+#define FOR_EACH_PARAM_OF_PQcancel(param) \
+	param(PGcancel *, cancel) \
+	param(char *, errbuf)
+
+/* function( name, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
 #define FOR_EACH_BLOCKING_FUNCTION(function) \
-	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) \
-	function(PQsendQuery, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, const char *, query) \
-	function(PQsendQueryParams, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, int, resultFormat) \
-	function(PQsendPrepare, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, const Oid *, paramTypes) \
-	function(PQsendQueryPrepared, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, int, resultFormat) \
-	function(PQsendDescribePrepared, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, const char *, stmt) \
-	function(PQsendDescribePortal, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, const char *, portal) \
-	function(PQisBusy, GVL_CANCELABLE, GVL_TYPE_NONVOID, int, PGconn *, conn);
+	function(PQconnectdb, GVL_TYPE_NONVOID, PGconn *, const char *, conninfo) \
+	function(PQconnectStart, GVL_TYPE_NONVOID, PGconn *, const char *, conninfo) \
+	function(PQconnectPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	function(PQreset, GVL_TYPE_VOID, void, PGconn *, conn) \
+	function(PQresetStart, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQresetPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	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(PQnotifies, GVL_TYPE_NONVOID, PGnotify *, PGconn *, conn) \
+	function(PQsendQuery, GVL_TYPE_NONVOID, int, const char *, query) \
+	function(PQsendQueryParams, GVL_TYPE_NONVOID, int, int, resultFormat) \
+	function(PQsendPrepare, GVL_TYPE_NONVOID, int, const Oid *, paramTypes) \
+	function(PQsendQueryPrepared, GVL_TYPE_NONVOID, int, int, resultFormat) \
+	function(PQsendDescribePrepared, GVL_TYPE_NONVOID, int, const char *, stmt) \
+	function(PQsendDescribePortal, GVL_TYPE_NONVOID, int, const char *, portal) \
+	function(PQisBusy, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQcancel, GVL_TYPE_NONVOID, int, int, errbufsize);
 
 
 FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
@@ -243,10 +243,10 @@ FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
 #define FOR_EACH_PARAM_OF_notice_receiver_proxy(param) \
 	param(void *, arg)
 
-/* function( name, cancel, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
+/* 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_connection.c

@@ -1,6 +1,6 @@
 /*
  * pg_connection.c - PG::Connection class extension
- * $Id: pg_connection.c,v d93b3ddc69ff 2013/09/07 21:12:59 lars $
+ * $Id: pg_connection.c,v 97c3ec224be9 2013/12/09 16:34:26 kanis $
  *
  */
 
@@ -292,7 +292,10 @@ pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
 }
 #endif
 
+
 /*
+ * Document-method: conndefaults
+ *
  * call-seq:
  *    PG::Connection.conndefaults() -> Array
  *
@@ -503,6 +506,7 @@ pgconn_reset_poll(VALUE self)
 	return INT2FIX((int)status);
 }
 
+
 /*
  * call-seq:
  *    conn.db()
@@ -838,6 +842,13 @@ static VALUE pgconn_exec_params( int, VALUE *, VALUE );
  * 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.
+ *
+ * #exec is implemented on the synchronous command processing API of libpq, whereas
+ * #async_exec is implemented on the asynchronous API.
+ * #exec is somewhat faster that #async_exec, but blocks any signals to be processed until
+ * the query is finished. This is most notably visible by a delayed reaction to Control+C.
+ * Both methods ensure that other threads can process while waiting for the server to
+ * complete the request.
  */
 static VALUE
 pgconn_exec(int argc, VALUE *argv, VALUE self)
@@ -2103,7 +2114,7 @@ pgconn_cancel(VALUE self)
 	if(cancel == NULL)
 		rb_raise(rb_ePGerror,"Invalid connection!");
 
-	ret = PQcancel(cancel, errbuf, 256);
+	ret = gvl_PQcancel(cancel, errbuf, 256);
 	if(ret == 1)
 		retval = Qnil;
 	else
@@ -3010,22 +3021,14 @@ pgconn_get_last_result(VALUE self)
 	return rb_pgresult;
 }
 
-#if !defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-
 /*
  * call-seq:
  *    conn.async_exec(sql [, params, result_format ] ) -> PG::Result
  *    conn.async_exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * This function has the same behavior as #exec,
- * but ensures that other threads can process while
- * waiting for the server to complete the request.
- *
- * On Ruby platforms with native threads (MRI-1.9+ and all others)
- * this method is an alias to #exec.
- *
- * On MRI-1.8 it's implemented using asynchronous command
- * processing and ruby's +rb_thread_select+ .
+ * but is implemented using the asynchronous command
+ * processing API of libpq.
  */
 static VALUE
 pgconn_async_exec(int argc, VALUE *argv, VALUE self)
@@ -3046,8 +3049,6 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 	return rb_pgresult;
 }
 
-#endif
-
 /**************************************************************************
  * LARGE OBJECT SUPPORT
  **************************************************************************/
@@ -3508,7 +3509,6 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "reset", pgconn_reset, 0);
 	rb_define_method(rb_cPGconn, "reset_start", pgconn_reset_start, 0);
 	rb_define_method(rb_cPGconn, "reset_poll", pgconn_reset_poll, 0);
-	rb_define_method(rb_cPGconn, "conndefaults", pgconn_s_conndefaults, 0);
 	rb_define_alias(rb_cPGconn, "close", "finish");
 
 	/******     PG::Connection INSTANCE METHODS: Connection Status     ******/
@@ -3600,11 +3600,7 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "wait_for_notify", pgconn_wait_for_notify, -1);
 	rb_define_alias(rb_cPGconn, "notifies_wait", "wait_for_notify");
 	rb_define_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
-#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-	rb_define_alias(rb_cPGconn, "async_exec", "exec");
-#else
 	rb_define_method(rb_cPGconn, "async_exec", pgconn_async_exec, -1);
-#endif
 	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
 	rb_define_method(rb_cPGconn, "get_last_result", pgconn_get_last_result, 0);
 

data/lib/pg.rb

@@ -19,10 +19,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.17.0'
+	VERSION = '0.17.1'
 
 	# VCS revision
-	REVISION = %q$Revision: 7cdff0a462e5 $
+	REVISION = %q$Revision: 22d57e3a2b37 $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end

data/lib/pg/connection.rb

@@ -164,6 +164,14 @@ class PG::Connection
 	class << self
 		define_method( :isthreadsafe, &PG.method(:isthreadsafe) )
 	end
+
+
+	### Returns an array of Hashes with connection defaults. See ::conndefaults
+	### for details.
+	def conndefaults
+		return self.class.conndefaults
+	end
+
 end # class PG::Connection
 
 # Backward-compatible alias

data/spec/pg/connection_spec.rb

@@ -262,7 +262,7 @@ describe PG::Connection do
 		error.should == true
 	end
 
-	it "can stop a thread that runs a blocking query" do
+	it "can stop a thread that runs a blocking query with async_exec" do
 		start = Time.now
 		t = Thread.new do
 			@conn.async_exec( 'select pg_sleep(10)' )
@@ -274,6 +274,29 @@ describe PG::Connection do
 		(Time.now - start).should < 10
 	end
 
+	it "should work together with signal handlers" do
+		signal_received = false
+		trap 'USR1' do
+			signal_received = true
+		end
+
+		Thread.new do
+			sleep 0.1
+			Process.kill("USR1", Process.pid)
+		end
+		@conn.exec("select pg_sleep(0.3)")
+		signal_received.should be_true
+
+		signal_received = false
+		Thread.new do
+			sleep 0.1
+			Process.kill("USR1", Process.pid)
+		end
+		@conn.async_exec("select pg_sleep(0.3)")
+		signal_received.should be_true
+	end
+
+
 	it "automatically rolls back a transaction started with Connection#transaction if an exception " +
 	   "is raised" do
 		# abort the per-example transaction so we can test our own

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg
 version: !ruby/object:Gem::Version
-  version: 0.17.0
+  version: 0.17.1
 platform: ruby
 authors:
 - Michael Granger
@@ -31,7 +31,7 @@ cert_chain:
   6mKCwjpegytE0oifXfF8k75A9105cBnNiMZOe1tXiqYc/exCgWvbggurzDOcRkZu
   /YSusaiDXHKU2O3Akc3htA==
   -----END CERTIFICATE-----
-date: 2013-09-16 00:00:00.000000000 Z
+date: 2013-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe-mercurial
@@ -259,7 +259,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: pg
-rubygems_version: 2.0.5
+rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Pg is the Ruby interface to the {PostgreSQL RDBMS}[http://www.postgresql.org/]