pg 1.3.3-x64-mingw32 → 1.4.0-x64-mingw32

data/ext/pg_connection.c

@@ -24,11 +24,32 @@ static VALUE pgconn_set_default_encoding( VALUE self );
 static VALUE pgconn_wait_for_flush( VALUE self );
 static void pgconn_set_internal_encoding_index( VALUE );
 static const rb_data_type_t pg_connection_type;
+static VALUE pgconn_async_flush(VALUE self);
 
 /*
  * Global functions
  */
 
+/*
+ * Convenience function to raise connection errors
+ */
+#ifdef __GNUC__
+__attribute__((format(printf, 3, 4)))
+#endif
+static void
+pg_raise_conn_error( VALUE klass, VALUE self, const char *format, ...)
+{
+	VALUE msg, error;
+	va_list ap;
+
+	va_start(ap, format);
+	msg = rb_vsprintf(format, ap);
+	va_end(ap);
+	error = rb_exc_new_str(klass, msg);
+	rb_iv_set(error, "@connection", self);
+	rb_exc_raise(error);
+}
+
 /*
  * Fetch the PG::Connection object data pointer.
  */
@@ -52,7 +73,7 @@ pg_get_connection_safe( VALUE self )
 	TypedData_Get_Struct( self, t_pg_connection, &pg_connection_type, this);
 
 	if ( !this->pgconn )
-		rb_raise( rb_eConnectionBad, "connection is closed" );
+		pg_raise_conn_error( rb_eConnectionBad, self, "connection is closed");
 
 	return this;
 }
@@ -70,8 +91,9 @@ pg_get_pgconn( VALUE self )
 	t_pg_connection *this;
 	TypedData_Get_Struct( self, t_pg_connection, &pg_connection_type, this);
 
-	if ( !this->pgconn )
-		rb_raise( rb_eConnectionBad, "connection is closed" );
+	if ( !this->pgconn ){
+		pg_raise_conn_error( rb_eConnectionBad, self, "connection is closed");
+	}
 
 	return this->pgconn;
 }
@@ -89,9 +111,8 @@ pgconn_close_socket_io( VALUE self )
 
 	if ( RTEST(socket_io) ) {
 #if defined(_WIN32)
-		if( rb_w32_unwrap_io_handle(this->ruby_sd) ){
-			rb_raise(rb_eConnectionBad, "Could not unwrap win32 socket handle");
-		}
+		if( rb_w32_unwrap_io_handle(this->ruby_sd) )
+			pg_raise_conn_error( rb_eConnectionBad, self, "Could not unwrap win32 socket handle");
 #endif
 		rb_funcall( socket_io, rb_intern("close"), 0 );
 	}
@@ -254,7 +275,6 @@ pgconn_s_sync_connect(int argc, VALUE *argv, VALUE klass)
 {
 	t_pg_connection *this;
 	VALUE conninfo;
-	VALUE error;
 	VALUE self = pgconn_s_allocate( klass );
 
 	this = pg_get_connection( self );
@@ -262,13 +282,10 @@ pgconn_s_sync_connect(int argc, VALUE *argv, VALUE klass)
 	this->pgconn = gvl_PQconnectdb(StringValueCStr(conninfo));
 
 	if(this->pgconn == NULL)
-		rb_raise(rb_ePGerror, "PQconnectdb() unable to allocate structure");
+		rb_raise(rb_ePGerror, "PQconnectdb() unable to allocate PGconn structure");
 
-	if (PQstatus(this->pgconn) == CONNECTION_BAD) {
-		error = rb_exc_new2(rb_eConnectionBad, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if (PQstatus(this->pgconn) == CONNECTION_BAD)
+		pg_raise_conn_error( rb_eConnectionBad, self, "%s", PQerrorMessage(this->pgconn));
 
 	pgconn_set_default_encoding( self );
 
@@ -301,7 +318,6 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 {
 	VALUE rb_conn;
 	VALUE conninfo;
-	VALUE error;
 	t_pg_connection *this;
 
 	/*
@@ -314,13 +330,10 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	this->pgconn = gvl_PQconnectStart( StringValueCStr(conninfo) );
 
 	if( this->pgconn == NULL )
-		rb_raise(rb_ePGerror, "PQconnectStart() unable to allocate structure");
+		rb_raise(rb_ePGerror, "PQconnectStart() unable to allocate PGconn structure");
 
-	if ( PQstatus(this->pgconn) == CONNECTION_BAD ) {
-		error = rb_exc_new2(rb_eConnectionBad, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", rb_conn);
-		rb_exc_raise(error);
-	}
+	if ( PQstatus(this->pgconn) == CONNECTION_BAD )
+		pg_raise_conn_error( rb_eConnectionBad, rb_conn, "%s", PQerrorMessage(this->pgconn));
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_conn, pgconn_finish, rb_conn );
@@ -376,6 +389,36 @@ pgconn_s_conndefaults(VALUE self)
 	return array;
 }
 
+/*
+ * Document-method: PG::Connection.conninfo_parse
+ *
+ * call-seq:
+ *    PG::Connection.conninfo_parse(conninfo_string) -> Array
+ *
+ * Returns parsed connection options from the provided connection string as an array of hashes.
+ * Each hash has the same keys as PG::Connection.conndefaults() .
+ * The values from the +conninfo_string+ are stored in the +:val+ key.
+ */
+static VALUE
+pgconn_s_conninfo_parse(VALUE self, VALUE conninfo)
+{
+	VALUE array;
+	char *errmsg = NULL;
+	PQconninfoOption *options = PQconninfoParse(StringValueCStr(conninfo), &errmsg);
+	if(errmsg){
+		VALUE error = rb_str_new_cstr(errmsg);
+		PQfreemem(errmsg);
+		rb_raise(rb_ePGerror, "%"PRIsVALUE, error);
+	}
+	array = pgconn_make_conninfo_array( options );
+
+	PQconninfoFree(options);
+
+	UNUSED( self );
+
+	return array;
+}
+
 
 #ifdef HAVE_PQENCRYPTPASSWORDCONN
 static VALUE
@@ -396,7 +439,7 @@ pgconn_sync_encrypt_password(int argc, VALUE *argv, VALUE self)
 		rval = rb_str_new2( encrypted );
 		PQfreemem( encrypted );
 	} else {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 	}
 
 	return rval;
@@ -450,17 +493,18 @@ pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
  *   the asynchronous connection is ready
  *
  * Example:
- *   conn = PG::Connection.connect_start("dbname=mydatabase")
- *   socket = conn.socket_io
+ *   require "io/wait"
+ *
+ *   conn = PG::Connection.connect_start(dbname: 'mydatabase')
  *   status = conn.connect_poll
  *   while(status != PG::PGRES_POLLING_OK) do
  *     # do some work while waiting for the connection to complete
  *     if(status == PG::PGRES_POLLING_READING)
- *       if(not select([socket], [], [], 10.0))
+ *       unless conn.socket_io.wait_readable(10.0)
  *         raise "Asynchronous connection timed out!"
  *       end
  *     elsif(status == PG::PGRES_POLLING_WRITING)
- *       if(not select([], [socket], [], 10.0))
+ *       unless conn.socket_io.wait_writable(10.0)
  *         raise "Asynchronous connection timed out!"
  *       end
  *     end
@@ -475,9 +519,7 @@ pgconn_connect_poll(VALUE self)
 	PostgresPollingStatusType status;
 	status = gvl_PQconnectPoll(pg_get_pgconn(self));
 
-	if ( status == PGRES_POLLING_FAILED ) {
-		pgconn_close_socket_io(self);
-	}
+	pgconn_close_socket_io(self);
 
 	return INT2FIX((int)status);
 }
@@ -538,7 +580,7 @@ pgconn_reset_start(VALUE self)
 {
 	pgconn_close_socket_io( self );
 	if(gvl_PQresetStart(pg_get_pgconn(self)) == 0)
-		rb_raise(rb_eUnableToSend, "reset has failed");
+		pg_raise_conn_error( rb_eUnableToSend, self, "reset has failed");
 	return Qnil;
 }
 
@@ -556,9 +598,7 @@ pgconn_reset_poll(VALUE self)
 	PostgresPollingStatusType status;
 	status = gvl_PQresetPoll(pg_get_pgconn(self));
 
-	if ( status == PGRES_POLLING_FAILED ) {
-		pgconn_close_socket_io(self);
-	}
+	pgconn_close_socket_io(self);
 
 	return INT2FIX((int)status);
 }
@@ -610,7 +650,18 @@ pgconn_pass(VALUE self)
  * call-seq:
  *    conn.host()
  *
- * Returns the connected server name.
+ * Returns the server host name of the active connection.
+ * This can be a host name, an IP address, or a directory path if the connection is via Unix socket.
+ * (The path case can be distinguished because it will always be an absolute path, beginning with +/+ .)
+ *
+ * If the connection parameters specified both host and hostaddr, then +host+ will return the host information.
+ * If only hostaddr was specified, then that is returned.
+ * If multiple hosts were specified in the connection parameters, +host+ returns the host actually connected to.
+ *
+ * If there is an error producing the host information (perhaps if the connection has not been fully established or there was an error), it returns an empty string.
+ *
+ * If multiple hosts were specified in the connection parameters, it is not possible to rely on the result of +host+ until the connection is established.
+ * The status of the connection can be checked using the function Connection#status .
  */
 static VALUE
 pgconn_host(VALUE self)
@@ -620,6 +671,26 @@ pgconn_host(VALUE self)
 	return rb_str_new2(host);
 }
 
+/* PQhostaddr() appeared in PostgreSQL-12 together with PQresultMemorySize() */
+#if defined(HAVE_PQRESULTMEMORYSIZE)
+/*
+ * call-seq:
+ *    conn.hostaddr()
+ *
+ * Returns the server IP address of the active connection.
+ * This can be the address that a host name resolved to, or an IP address provided through the hostaddr parameter.
+ * If there is an error producing the host information (perhaps if the connection has not been fully established or there was an error), it returns an empty string.
+ *
+ */
+static VALUE
+pgconn_hostaddr(VALUE self)
+{
+	char *host = PQhostaddr(pg_get_pgconn(self));
+	if (!host) return Qnil;
+	return rb_str_new2(host);
+}
+#endif
+
 /*
  * call-seq:
  *    conn.port()
@@ -690,6 +761,9 @@ pgconn_conninfo( VALUE self )
  *   PG::Constants::CONNECTION_BAD
  *
  * ... and other constants of kind PG::Constants::CONNECTION_*
+ *
+ * Example:
+ *   PG.constants.grep(/CONNECTION_/).find{|c| PG.const_get(c) == conn.status} # => :CONNECTION_OK
  */
 static VALUE
 pgconn_status(VALUE self)
@@ -814,7 +888,8 @@ pgconn_socket(VALUE self)
 	pg_deprecated(4, ("conn.socket is deprecated and should be replaced by conn.socket_io"));
 
 	if( (sd = PQsocket(pg_get_pgconn(self))) < 0)
-		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
+		pg_raise_conn_error( rb_eConnectionBad, self, "PQsocket() can't get socket descriptor");
+
 	return INT2NUM(sd);
 }
 
@@ -822,13 +897,15 @@ pgconn_socket(VALUE self)
  * call-seq:
  *    conn.socket_io() -> IO
  *
- * Fetch a memorized IO object created from the Connection's underlying socket.
- * This object can be used for IO.select to wait for events while running
- * asynchronous API calls.
+ * Fetch an IO object created from the Connection's underlying socket.
+ * This object can be used per <tt>socket_io.wait_readable</tt>, <tt>socket_io.wait_writable</tt> or for <tt>IO.select</tt> to wait for events while running asynchronous API calls.
+ * <tt>IO#wait_*able</tt> is is <tt>Fiber.scheduler</tt> compatible in contrast to <tt>IO.select</tt>.
+ *
+ * The IO object can change while the connection is established, but is memorized afterwards.
+ * So be sure not to cache the IO object, but repeat calling <tt>conn.socket_io</tt> instead.
  *
- * Using this instead of #socket avoids the problem of the underlying connection
- * being closed by Ruby when an IO created using <tt>IO.for_fd(conn.socket)</tt>
- * goes out of scope. In contrast to #socket, it also works on Windows.
+ * Using this method also works on Windows in contrast to using #socket .
+ * It also avoids the problem of the underlying connection being closed by Ruby when an IO created using <tt>IO.for_fd(conn.socket)</tt> goes out of scope.
  */
 static VALUE
 pgconn_socket_io(VALUE self)
@@ -840,14 +917,15 @@ pgconn_socket_io(VALUE self)
 	VALUE socket_io = this->socket_io;
 
 	if ( !RTEST(socket_io) ) {
-		if( (sd = PQsocket(this->pgconn)) < 0)
-			rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
+		if( (sd = PQsocket(this->pgconn)) < 0){
+			pg_raise_conn_error( rb_eConnectionBad, self, "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);
-			if( ruby_sd == -1 ){
-				rb_raise(rb_eConnectionBad, "Could not wrap win32 socket handle");
-			}
+			if( ruby_sd == -1 )
+				pg_raise_conn_error( rb_eConnectionBad, self, "Could not wrap win32 socket handle");
+
 			this->ruby_sd = ruby_sd;
 		#else
 			ruby_sd = sd;
@@ -912,7 +990,7 @@ pgconn_backend_key(VALUE self)
 
 	cancel = (struct pg_cancel*)PQgetCancel(conn);
 	if(cancel == NULL)
-		rb_raise(rb_ePGerror,"Invalid connection!");
+		pg_raise_conn_error( rb_ePGerror, self, "Invalid connection!");
 
 	if( cancel->be_pid != PQbackendPID(conn) )
 		rb_raise(rb_ePGerror,"Unexpected binary struct layout - please file a bug report at ruby-pg!");
@@ -1541,9 +1619,9 @@ pgconn_s_escape(VALUE self, VALUE string)
 	if( !singleton ) {
 		size = PQescapeStringConn(pg_get_pgconn(self), RSTRING_PTR(result),
 			RSTRING_PTR(string), RSTRING_LEN(string), &error);
-		if(error) {
-			rb_raise(rb_ePGerror, "%s", PQerrorMessage(pg_get_pgconn(self)));
-		}
+		if(error)
+			pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(pg_get_pgconn(self)));
+
 	} else {
 		size = PQescapeString(RSTRING_PTR(result), RSTRING_PTR(string), RSTRING_LEN(string));
 	}
@@ -1639,7 +1717,6 @@ pgconn_escape_literal(VALUE self, VALUE string)
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
 	char *escaped = NULL;
-	VALUE error;
 	VALUE result = Qnil;
 	int enc_idx = this->enc_idx;
 
@@ -1650,12 +1727,8 @@ pgconn_escape_literal(VALUE self, VALUE string)
 
 	escaped = PQescapeLiteral(this->pgconn, RSTRING_PTR(string), RSTRING_LEN(string));
 	if (escaped == NULL)
-	{
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-		return Qnil;
-	}
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
+
 	result = rb_str_new2(escaped);
 	PQfreemem(escaped);
 	PG_ENCODING_SET_NOCHECK(result, enc_idx);
@@ -1678,7 +1751,6 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
 	char *escaped = NULL;
-	VALUE error;
 	VALUE result = Qnil;
 	int enc_idx = this->enc_idx;
 
@@ -1689,12 +1761,8 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 
 	escaped = PQescapeIdentifier(this->pgconn, RSTRING_PTR(string), RSTRING_LEN(string));
 	if (escaped == NULL)
-	{
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-		return Qnil;
-	}
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
+
 	result = rb_str_new2(escaped);
 	PQfreemem(escaped);
 	PG_ENCODING_SET_NOCHECK(result, enc_idx);
@@ -1742,14 +1810,9 @@ 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);
-	}
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 
 	return self;
 }
@@ -1773,15 +1836,12 @@ static VALUE
 pgconn_send_query(int argc, VALUE *argv, VALUE self)
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
-	VALUE error;
 
 	/* If called with no or nil parameters, use PQexec for compatibility */
 	if ( argc == 1 || (argc >= 2 && argc <= 4 && NIL_P(argv[1]) )) {
-		if(gvl_PQsendQuery(this->pgconn, pg_cstr_enc(argv[0], this->enc_idx)) == 0) {
-			error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(this->pgconn));
-			rb_iv_set(error, "@connection", self);
-			rb_exc_raise(error);
-		}
+		if(gvl_PQsendQuery(this->pgconn, pg_cstr_enc(argv[0], this->enc_idx)) == 0)
+			pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+
 		pgconn_wait_for_flush( self );
 		return Qnil;
 	}
@@ -1838,7 +1898,6 @@ pgconn_send_query_params(int argc, VALUE *argv, VALUE self)
 	t_pg_connection *this = pg_get_connection_safe( self );
 	int result;
 	VALUE command, in_res_fmt;
-	VALUE error;
 	int nParams;
 	int resultFormat;
 	struct query_params_data paramsData = { this->enc_idx };
@@ -1855,11 +1914,9 @@ pgconn_send_query_params(int argc, VALUE *argv, VALUE self)
 
 	free_query_params( &paramsData );
 
-	if(result == 0) {
-		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(result == 0)
+		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+
 	pgconn_wait_for_flush( self );
 	return Qnil;
 }
@@ -1891,7 +1948,6 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	int result;
 	VALUE name, command, in_paramtypes;
 	VALUE param;
-	VALUE error;
 	int i = 0;
 	int nParams = 0;
 	Oid *paramTypes = NULL;
@@ -1920,9 +1976,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	xfree(paramTypes);
 
 	if(result == 0) {
-		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
+		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
 	}
 	pgconn_wait_for_flush( self );
 	return Qnil;
@@ -1966,7 +2020,6 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 	t_pg_connection *this = pg_get_connection_safe( self );
 	int result;
 	VALUE name, in_res_fmt;
-	VALUE error;
 	int nParams;
 	int resultFormat;
 	struct query_params_data paramsData = { this->enc_idx };
@@ -1988,11 +2041,9 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 
 	free_query_params( &paramsData );
 
-	if(result == 0) {
-		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(result == 0)
+		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+
 	pgconn_wait_for_flush( self );
 	return Qnil;
 }
@@ -2007,14 +2058,11 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 static VALUE
 pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 {
-	VALUE error;
 	t_pg_connection *this = pg_get_connection_safe( self );
 	/* returns 0 on failure */
-	if(gvl_PQsendDescribePrepared(this->pgconn, pg_cstr_enc(stmt_name, this->enc_idx)) == 0) {
-		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(gvl_PQsendDescribePrepared(this->pgconn, pg_cstr_enc(stmt_name, this->enc_idx)) == 0)
+		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+
 	pgconn_wait_for_flush( self );
 	return Qnil;
 }
@@ -2030,14 +2078,11 @@ pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 static VALUE
 pgconn_send_describe_portal(VALUE self, VALUE portal)
 {
-	VALUE error;
 	t_pg_connection *this = pg_get_connection_safe( self );
 	/* returns 0 on failure */
-	if(gvl_PQsendDescribePortal(this->pgconn, pg_cstr_enc(portal, this->enc_idx)) == 0) {
-		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(gvl_PQsendDescribePortal(this->pgconn, pg_cstr_enc(portal, this->enc_idx)) == 0)
+		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+
 	pgconn_wait_for_flush( self );
 	return Qnil;
 }
@@ -2070,18 +2115,15 @@ pgconn_sync_get_result(VALUE self)
  * or *notifies* to see if the state has changed.
  */
 static VALUE
-pgconn_consume_input(self)
-	VALUE self;
+pgconn_consume_input(VALUE self)
 {
-	VALUE error;
 	PGconn *conn = pg_get_pgconn(self);
 	/* returns 0 on error */
 	if(PQconsumeInput(conn) == 0) {
 		pgconn_close_socket_io(self);
-		error = rb_exc_new2(rb_eConnectionBad, PQerrorMessage(conn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
+		pg_raise_conn_error( rb_eConnectionBad, self, "%s", PQerrorMessage(conn));
 	}
+
 	return Qnil;
 }
 
@@ -2093,18 +2135,15 @@ pgconn_consume_input(self)
  * #get_result would block. Otherwise returns +false+.
  */
 static VALUE
-pgconn_is_busy(self)
-	VALUE self;
+pgconn_is_busy(VALUE self)
 {
 	return gvl_PQisBusy(pg_get_pgconn(self)) ? Qtrue : Qfalse;
 }
 
 static VALUE
-pgconn_sync_setnonblocking(self, state)
-	VALUE self, state;
+pgconn_sync_setnonblocking(VALUE self, VALUE state)
 {
 	int arg;
-	VALUE error;
 	PGconn *conn = pg_get_pgconn(self);
 	if(state == Qtrue)
 		arg = 1;
@@ -2113,18 +2152,15 @@ pgconn_sync_setnonblocking(self, state)
 	else
 		rb_raise(rb_eArgError, "Boolean value expected");
 
-	if(PQsetnonblocking(conn, arg) == -1) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(PQsetnonblocking(conn, arg) == -1)
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
 	return Qnil;
 }
 
 
 static VALUE
-pgconn_sync_isnonblocking(self)
-	VALUE self;
+pgconn_sync_isnonblocking(VALUE self)
 {
 	return PQisnonblocking(pg_get_pgconn(self)) ? Qtrue : Qfalse;
 }
@@ -2133,14 +2169,10 @@ static VALUE
 pgconn_sync_flush(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
-	int ret;
-	VALUE error;
-	ret = PQflush(conn);
-	if(ret == -1) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(conn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	int ret = PQflush(conn);
+	if(ret == -1)
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
 	return (ret) ? Qfalse : Qtrue;
 }
 
@@ -2154,7 +2186,7 @@ pgconn_sync_cancel(VALUE self)
 
 	cancel = PQgetCancel(pg_get_pgconn(self));
 	if(cancel == NULL)
-		rb_raise(rb_ePGerror,"Invalid connection!");
+		pg_raise_conn_error( rb_ePGerror, self, "Invalid connection!");
 
 	ret = gvl_PQcancel(cancel, errbuf, sizeof(errbuf));
 	if(ret == 1)
@@ -2343,21 +2375,12 @@ pg_rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
 static void *
 wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
 {
-	VALUE socket_io;
 	VALUE ret;
 	void *retval;
 	struct timeval aborttime={0,0}, currtime, waittime;
 	VALUE wait_timeout = Qnil;
 	PGconn *conn = pg_get_pgconn(self);
 
-	socket_io = pgconn_socket_io(self);
-
-	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if ( PQconsumeInput(conn) == 0 ) {
-		pgconn_close_socket_io(self);
-		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
-	}
-
 	if ( ptimeout ) {
 		gettimeofday(&currtime, NULL);
 		timeradd(&currtime, ptimeout, &aborttime);
@@ -2372,6 +2395,14 @@ wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)
 
 		/* Is the given timeout valid? */
 		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
+			VALUE socket_io;
+
+			/* before we wait for data, make sure everything has been sent */
+			pgconn_async_flush(self);
+			if ((retval=is_readable(conn)))
+				return retval;
+
+			socket_io = pgconn_socket_io(self);
 			/* Wait for the socket to become readable before checking again */
 			ret = pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), wait_timeout);
 		} else {
@@ -2386,7 +2417,7 @@ wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)
 		/* Check for connection errors (PQisBusy is true on connection errors) */
 		if ( PQconsumeInput(conn) == 0 ){
 			pgconn_close_socket_io(self);
-			rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
+			pg_raise_conn_error(rb_eConnectionBad, self, "PQconsumeInput() %s", PQerrorMessage(conn));
 		}
 	}
 
@@ -2399,8 +2430,8 @@ wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)
  *
  * Attempts to flush any queued output data to the server.
  * Returns +true+ if data is successfully flushed, +false+
- * if not (can only return +false+ if connection is
- * nonblocking.
+ * if not. It can only return +false+ if connection is
+ * in nonblocking mode.
  * Raises PG::Error if some other failure occurred.
  */
 static VALUE
@@ -2536,11 +2567,9 @@ pgconn_sync_put_copy_data(int argc, VALUE *argv, VALUE self)
 	Check_Type(buffer, T_STRING);
 
 	ret = gvl_PQputCopyData(this->pgconn, RSTRING_PTR(buffer), RSTRING_LENINT(buffer));
-	if(ret == -1) {
-		VALUE error = rb_exc_new2(rb_ePGerror, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(ret == -1)
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
+
 	RB_GC_GUARD(intermediate);
 	RB_GC_GUARD(buffer);
 
@@ -2551,7 +2580,6 @@ static VALUE
 pgconn_sync_put_copy_end(int argc, VALUE *argv, VALUE self)
 {
 	VALUE str;
-	VALUE error;
 	int ret;
 	const char *error_message = NULL;
 	t_pg_connection *this = pg_get_connection_safe( self );
@@ -2562,11 +2590,9 @@ pgconn_sync_put_copy_end(int argc, VALUE *argv, VALUE self)
 		error_message = pg_cstr_enc(str, this->enc_idx);
 
 	ret = gvl_PQputCopyEnd(this->pgconn, error_message);
-	if(ret == -1) {
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
-	}
+	if(ret == -1)
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
+
 	return (ret) ? Qtrue : Qfalse;
 }
 
@@ -2574,7 +2600,6 @@ static VALUE
 pgconn_sync_get_copy_data(int argc, VALUE *argv, VALUE self )
 {
 	VALUE async_in;
-	VALUE error;
 	VALUE result;
 	int ret;
 	char *buffer;
@@ -2594,10 +2619,8 @@ pgconn_sync_get_copy_data(int argc, VALUE *argv, VALUE self )
 	}
 
 	ret = gvl_PQgetCopyData(this->pgconn, &buffer, RTEST(async_in));
-	if(ret == -2) { /* error */
-		error = rb_exc_new2(rb_ePGerror, PQerrorMessage(this->pgconn));
-		rb_iv_set(error, "@connection", self);
-		rb_exc_raise(error);
+	if(ret == -2){ /* error */
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
 	}
 	if(ret == -1) { /* No data left */
 		return Qnil;
@@ -2902,9 +2925,9 @@ pgconn_sync_set_client_encoding(VALUE self, VALUE str)
 
 	Check_Type(str, T_STRING);
 
-	if ( (gvl_PQsetClientEncoding(conn, StringValueCStr(str))) == -1 ) {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
-	}
+	if ( (gvl_PQsetClientEncoding(conn, StringValueCStr(str))) == -1 )
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
 	pgconn_set_internal_encoding_index( self );
 
 	return Qnil;
@@ -2984,7 +3007,7 @@ get_result_readable(PGconn *conn)
  * If +true+ is returned, +conn.is_busy+ will return +false+
  * and +conn.get_result+ will not block.
  */
-static VALUE
+VALUE
 pgconn_block( int argc, VALUE *argv, VALUE self ) {
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
@@ -3072,7 +3095,8 @@ pgconn_async_get_last_result(VALUE self)
 	for(;;) {
 		int status;
 
-		pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
+		/* wait for input (without blocking) before reading each result */
+		wait_socket_readable(self, NULL, get_result_readable);
 
 		cur = gvl_PQgetResult(conn);
 		if (cur == NULL)
@@ -3536,11 +3560,10 @@ pgconn_enter_pipeline_mode(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int res = PQenterPipelineMode(conn);
-	if( res == 1 ) {
-		return Qnil;
-	} else {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
-	}
+	if( res != 1 )
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
+	return Qnil;
 }
 
 /*
@@ -3559,11 +3582,10 @@ pgconn_exit_pipeline_mode(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int res = PQexitPipelineMode(conn);
-	if( res == 1 ) {
-		return Qnil;
-	} else {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
-	}
+	if( res != 1 )
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
+	return Qnil;
 }
 
 
@@ -3583,11 +3605,10 @@ pgconn_pipeline_sync(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int res = PQpipelineSync(conn);
-	if( res == 1 ) {
-		return Qnil;
-	} else {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
-	}
+	if( res != 1 )
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
+	return Qnil;
 }
 
 /*
@@ -3607,11 +3628,10 @@ pgconn_send_flush_request(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int res = PQsendFlushRequest(conn);
-	if( res == 1 ) {
-		return Qnil;
-	} else {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
-	}
+	if( res != 1 )
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
+	return Qnil;
 }
 
 #endif
@@ -3642,7 +3662,7 @@ pgconn_locreat(int argc, VALUE *argv, VALUE self)
 
 	lo_oid = lo_creat(conn, mode);
 	if (lo_oid == 0)
-		rb_raise(rb_ePGerror, "lo_creat failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_creat failed");
 
 	return UINT2NUM(lo_oid);
 }
@@ -3663,7 +3683,7 @@ pgconn_locreate(VALUE self, VALUE in_lo_oid)
 
 	ret = lo_create(conn, lo_oid);
 	if (ret == InvalidOid)
-		rb_raise(rb_ePGerror, "lo_create failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_create failed");
 
 	return UINT2NUM(ret);
 }
@@ -3687,7 +3707,7 @@ pgconn_loimport(VALUE self, VALUE filename)
 
 	lo_oid = lo_import(conn, StringValueCStr(filename));
 	if (lo_oid == 0) {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 	}
 	return UINT2NUM(lo_oid);
 }
@@ -3708,7 +3728,7 @@ pgconn_loexport(VALUE self, VALUE lo_oid, VALUE filename)
 	oid = NUM2UINT(lo_oid);
 
 	if (lo_export(conn, oid, StringValueCStr(filename)) < 0) {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 	}
 	return Qnil;
 }
@@ -3739,7 +3759,7 @@ pgconn_loopen(int argc, VALUE *argv, VALUE self)
 		mode = NUM2INT(nmode);
 
 	if((fd = lo_open(conn, lo_oid, mode)) < 0) {
-		rb_raise(rb_ePGerror, "can't open large object: %s", PQerrorMessage(conn));
+		pg_raise_conn_error( rb_ePGerror, self, "can't open large object: %s", PQerrorMessage(conn));
 	}
 	return INT2FIX(fd);
 }
@@ -3761,11 +3781,11 @@ pgconn_lowrite(VALUE self, VALUE in_lo_desc, VALUE buffer)
 	Check_Type(buffer, T_STRING);
 
 	if( RSTRING_LEN(buffer) < 0) {
-		rb_raise(rb_ePGerror, "write buffer zero string");
+		pg_raise_conn_error( rb_ePGerror, self, "write buffer zero string");
 	}
 	if((n = lo_write(conn, fd, StringValuePtr(buffer),
 				RSTRING_LEN(buffer))) < 0) {
-		rb_raise(rb_ePGerror, "lo_write failed: %s", PQerrorMessage(conn));
+		pg_raise_conn_error( rb_ePGerror, self, "lo_write failed: %s", PQerrorMessage(conn));
 	}
 
 	return INT2FIX(n);
@@ -3788,16 +3808,12 @@ pgconn_loread(VALUE self, VALUE in_lo_desc, VALUE in_len)
 	VALUE str;
 	char *buffer;
 
-  buffer = ALLOC_N(char, len);
-	if(buffer == NULL)
-		rb_raise(rb_eNoMemError, "ALLOC failed!");
-
-	if (len < 0){
-		rb_raise(rb_ePGerror,"nagative length %d given", len);
-	}
+	if (len < 0)
+		pg_raise_conn_error( rb_ePGerror, self, "negative length %d given", len);
 
+	buffer = ALLOC_N(char, len);
 	if((ret = lo_read(conn, lo_desc, buffer, len)) < 0)
-		rb_raise(rb_ePGerror, "lo_read failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_read failed");
 
 	if(ret == 0) {
 		xfree(buffer);
@@ -3827,7 +3843,7 @@ pgconn_lolseek(VALUE self, VALUE in_lo_desc, VALUE offset, VALUE whence)
 	int ret;
 
 	if((ret = lo_lseek(conn, lo_desc, NUM2INT(offset), NUM2INT(whence))) < 0) {
-		rb_raise(rb_ePGerror, "lo_lseek failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_lseek failed");
 	}
 
 	return INT2FIX(ret);
@@ -3847,7 +3863,7 @@ pgconn_lotell(VALUE self, VALUE in_lo_desc)
 	int lo_desc = NUM2INT(in_lo_desc);
 
 	if((position = lo_tell(conn, lo_desc)) < 0)
-		rb_raise(rb_ePGerror,"lo_tell failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_tell failed");
 
 	return INT2FIX(position);
 }
@@ -3866,7 +3882,7 @@ pgconn_lotruncate(VALUE self, VALUE in_lo_desc, VALUE in_len)
 	size_t len = NUM2INT(in_len);
 
 	if(lo_truncate(conn,lo_desc,len) < 0)
-		rb_raise(rb_ePGerror,"lo_truncate failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_truncate failed");
 
 	return Qnil;
 }
@@ -3884,7 +3900,7 @@ pgconn_loclose(VALUE self, VALUE in_lo_desc)
 	int lo_desc = NUM2INT(in_lo_desc);
 
 	if(lo_close(conn,lo_desc) < 0)
-		rb_raise(rb_ePGerror,"lo_close failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_close failed");
 
 	return Qnil;
 }
@@ -3902,7 +3918,7 @@ pgconn_lounlink(VALUE self, VALUE in_oid)
 	Oid oid = NUM2UINT(in_oid);
 
 	if(lo_unlink(conn,oid) < 0)
-		rb_raise(rb_ePGerror,"lo_unlink failed");
+		pg_raise_conn_error( rb_ePGerror, self, "lo_unlink failed");
 
 	return Qnil;
 }
@@ -4336,6 +4352,7 @@ init_pg_connection()
 	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);
+	rb_define_singleton_method(rb_cPGconn, "conninfo_parse", pgconn_s_conninfo_parse, 1);
 	rb_define_singleton_method(rb_cPGconn, "sync_ping", pgconn_s_sync_ping, -1);
 	rb_define_singleton_method(rb_cPGconn, "sync_connect", pgconn_s_sync_connect, -1);
 
@@ -4353,6 +4370,9 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "user", pgconn_user, 0);
 	rb_define_method(rb_cPGconn, "pass", pgconn_pass, 0);
 	rb_define_method(rb_cPGconn, "host", pgconn_host, 0);
+#if defined(HAVE_PQRESULTMEMORYSIZE)
+	rb_define_method(rb_cPGconn, "hostaddr", pgconn_hostaddr, 0);
+#endif
 	rb_define_method(rb_cPGconn, "port", pgconn_port, 0);
 	rb_define_method(rb_cPGconn, "tty", pgconn_tty, 0);
 	rb_define_method(rb_cPGconn, "conninfo", pgconn_conninfo, 0);