pg 1.3.4 → 1.5.3

data/ext/pg_connection.c

@@ -16,19 +16,37 @@ static ID s_id_autoclose_set;
 static VALUE sym_type, sym_format, sym_value;
 static VALUE sym_symbol, sym_string, sym_static_symbol;
 
-static PQnoticeReceiver default_notice_receiver = NULL;
-static PQnoticeProcessor default_notice_processor = NULL;
-
 static VALUE pgconn_finish( VALUE );
 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 +70,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 +88,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,14 +108,13 @@ 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 );
 	}
 
-	this->socket_io = Qnil;
+	RB_OBJ_WRITE(self, &this->socket_io, Qnil);
 }
 
 
@@ -216,7 +234,7 @@ static const rb_data_type_t pg_connection_type = {
 	},
 	0,
 	0,
-	0,
+	RUBY_TYPED_WB_PROTECTED,
 };
 
 
@@ -237,14 +255,15 @@ pgconn_s_allocate( VALUE klass )
 	VALUE self = TypedData_Make_Struct( klass, t_pg_connection, &pg_connection_type, this );
 
 	this->pgconn = NULL;
-	this->socket_io = Qnil;
-	this->notice_receiver = Qnil;
-	this->notice_processor = Qnil;
-	this->type_map_for_queries = pg_typemap_all_strings;
-	this->type_map_for_results = pg_typemap_all_strings;
-	this->encoder_for_put_copy_data = Qnil;
-	this->decoder_for_get_copy_data = Qnil;
-	this->trace_stream = Qnil;
+	RB_OBJ_WRITE(self, &this->socket_io, Qnil);
+	RB_OBJ_WRITE(self, &this->notice_receiver, Qnil);
+	RB_OBJ_WRITE(self, &this->notice_processor, Qnil);
+	RB_OBJ_WRITE(self, &this->type_map_for_queries, pg_typemap_all_strings);
+	RB_OBJ_WRITE(self, &this->type_map_for_results, pg_typemap_all_strings);
+	RB_OBJ_WRITE(self, &this->encoder_for_put_copy_data, Qnil);
+	RB_OBJ_WRITE(self, &this->decoder_for_get_copy_data, Qnil);
+	RB_OBJ_WRITE(self, &this->trace_stream, Qnil);
+	rb_ivar_set(self, rb_intern("@calls_to_put_copy_data"), INT2FIX(0));
 
 	return self;
 }
@@ -254,7 +273,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 +280,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 +316,6 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 {
 	VALUE rb_conn;
 	VALUE conninfo;
-	VALUE error;
 	t_pg_connection *this;
 
 	/*
@@ -314,13 +328,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 +387,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 +437,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 +491,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
@@ -536,7 +578,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;
 }
 
@@ -606,7 +648,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)
@@ -616,6 +669,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()
@@ -626,7 +699,10 @@ static VALUE
 pgconn_port(VALUE self)
 {
 	char* port = PQport(pg_get_pgconn(self));
-	return INT2NUM(atoi(port));
+	if (!port || port[0] == '\0')
+		return INT2NUM(DEF_PGPORT);
+	else
+		return INT2NUM(atoi(port));
 }
 
 /*
@@ -686,6 +762,13 @@ pgconn_conninfo( VALUE self )
  *   PG::Constants::CONNECTION_BAD
  *
  * ... and other constants of kind PG::Constants::CONNECTION_*
+ *
+ * This method returns the status of the last command from memory.
+ * It doesn't do any socket access hence is not suitable to test the connectivity.
+ * See check_socket for a way to verify the socket state.
+ *
+ * Example:
+ *   PG.constants.grep(/CONNECTION_/).find{|c| PG.const_get(c) == conn.status} # => :CONNECTION_OK
  */
 static VALUE
 pgconn_status(VALUE self)
@@ -810,7 +893,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);
 }
 
@@ -818,13 +902,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)
@@ -836,14 +922,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;
@@ -855,7 +942,7 @@ pgconn_socket_io(VALUE self)
 		/* Disable autoclose feature */
 		rb_funcall( socket_io, s_id_autoclose_set, 1, Qfalse );
 
-		this->socket_io = socket_io;
+		RB_OBJ_WRITE(self, &this->socket_io, socket_io);
 	}
 
 	return socket_io;
@@ -908,7 +995,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!");
@@ -1072,7 +1159,7 @@ static const rb_data_type_t pg_typecast_buffer_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static char *
@@ -1105,7 +1192,7 @@ static const rb_data_type_t pg_query_heap_pool_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static int
@@ -1444,8 +1531,7 @@ pgconn_sync_describe_prepared(VALUE self, VALUE stmt_name)
  * It's not recommended to use explicit sync or async variants but #describe_portal instead, unless you have a good reason to do so.
  */
 static VALUE
-pgconn_sync_describe_portal(self, stmt_name)
-	VALUE self, stmt_name;
+pgconn_sync_describe_portal(VALUE self, VALUE stmt_name)
 {
 	PGresult *result;
 	VALUE rb_pgresult;
@@ -1537,9 +1623,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));
 	}
@@ -1635,7 +1721,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;
 
@@ -1646,12 +1731,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);
@@ -1674,7 +1755,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;
 
@@ -1685,12 +1765,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);
@@ -1738,14 +1814,10 @@ static VALUE
 pgconn_set_single_row_mode(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
-	VALUE error;
 
+	rb_check_frozen(self);
 	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;
 }
@@ -1769,15 +1841,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;
 	}
@@ -1834,7 +1903,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 };
@@ -1851,11 +1919,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;
 }
@@ -1887,7 +1953,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;
@@ -1916,9 +1981,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;
@@ -1962,7 +2025,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 };
@@ -1984,11 +2046,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;
 }
@@ -2003,14 +2063,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;
 }
@@ -2026,14 +2083,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;
 }
@@ -2066,18 +2120,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;
 }
 
@@ -2089,19 +2140,17 @@ 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);
+	rb_check_frozen(self);
 	if(state == Qtrue)
 		arg = 1;
 	else if (state == Qfalse)
@@ -2109,18 +2158,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;
 }
@@ -2129,14 +2175,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;
 }
 
@@ -2150,7 +2192,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)
@@ -2359,7 +2401,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 = pgconn_socket_io(self);
+			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 {
@@ -2374,7 +2423,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));
 		}
 	}
 
@@ -2387,8 +2436,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
@@ -2400,8 +2449,9 @@ pgconn_async_flush(VALUE self)
 		VALUE socket_io = pgconn_socket_io(self);
 		events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
 
-		if (events & PG_RUBY_IO_READABLE)
+		if (events & PG_RUBY_IO_READABLE){
 			pgconn_consume_input(self);
+		}
 	}
 	return Qtrue;
 }
@@ -2417,6 +2467,7 @@ pgconn_wait_for_flush( VALUE self ){
 static VALUE
 pgconn_flush_data_set( VALUE self, VALUE enabled ){
 	t_pg_connection *conn = pg_get_connection(self);
+	rb_check_frozen(self);
 	conn->flush_data = RTEST(enabled);
 	return enabled;
 }
@@ -2524,11 +2575,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);
 
@@ -2539,7 +2588,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 );
@@ -2550,11 +2598,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;
 }
 
@@ -2562,7 +2608,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;
@@ -2582,10 +2627,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;
@@ -2679,6 +2722,7 @@ pgconn_trace(VALUE self, VALUE stream)
 	VALUE new_file;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
+	rb_check_frozen(self);
 	if(!rb_respond_to(stream,rb_intern("fileno")))
 		rb_raise(rb_eArgError, "stream does not respond to method: fileno");
 
@@ -2700,7 +2744,7 @@ pgconn_trace(VALUE self, VALUE stream)
 		rb_raise(rb_eArgError, "stream is not writable");
 
 	new_file = rb_funcall(rb_cIO, rb_intern("new"), 1, INT2NUM(new_fd));
-	this->trace_stream = new_file;
+	RB_OBJ_WRITE(self, &this->trace_stream, new_file);
 
 	PQtrace(this->pgconn, new_fp);
 	return Qnil;
@@ -2719,7 +2763,7 @@ pgconn_untrace(VALUE self)
 
 	PQuntrace(this->pgconn);
 	rb_funcall(this->trace_stream, rb_intern("close"), 0);
-	this->trace_stream = Qnil;
+	RB_OBJ_WRITE(self, &this->trace_stream, Qnil);
 	return Qnil;
 }
 
@@ -2778,13 +2822,14 @@ pgconn_set_notice_receiver(VALUE self)
 	VALUE proc, old_proc;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
+	rb_check_frozen(self);
 	/* If default_notice_receiver is unset, assume that the current
 	 * notice receiver is the default, and save it to a global variable.
 	 * This should not be a problem because the default receiver is
 	 * always the same, so won't vary among connections.
 	 */
-	if(default_notice_receiver == NULL)
-		default_notice_receiver = PQsetNoticeReceiver(this->pgconn, NULL, NULL);
+	if(this->default_notice_receiver == NULL)
+		this->default_notice_receiver = PQsetNoticeReceiver(this->pgconn, NULL, NULL);
 
 	old_proc = this->notice_receiver;
 	if( rb_block_given_p() ) {
@@ -2793,10 +2838,10 @@ pgconn_set_notice_receiver(VALUE self)
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
-		PQsetNoticeReceiver(this->pgconn, default_notice_receiver, NULL);
+		PQsetNoticeReceiver(this->pgconn, this->default_notice_receiver, NULL);
 	}
 
-	this->notice_receiver = proc;
+	RB_OBJ_WRITE(self, &this->notice_receiver, proc);
 	return old_proc;
 }
 
@@ -2811,10 +2856,10 @@ notice_processor_proxy(void *arg, const char *message)
 	VALUE self = (VALUE)arg;
 	t_pg_connection *this = pg_get_connection( self );
 
-	if (this->notice_receiver != Qnil) {
+	if (this->notice_processor != Qnil) {
 		VALUE message_str = rb_str_new2(message);
 		PG_ENCODING_SET_NOCHECK( message_str, this->enc_idx );
-		rb_funcall(this->notice_receiver, rb_intern("call"), 1, message_str);
+		rb_funcall(this->notice_processor, rb_intern("call"), 1, message_str);
 	}
 	return;
 }
@@ -2838,25 +2883,26 @@ pgconn_set_notice_processor(VALUE self)
 	VALUE proc, old_proc;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
+	rb_check_frozen(self);
 	/* If default_notice_processor is unset, assume that the current
 	 * notice processor is the default, and save it to a global variable.
 	 * This should not be a problem because the default processor is
 	 * always the same, so won't vary among connections.
 	 */
-	if(default_notice_processor == NULL)
-		default_notice_processor = PQsetNoticeProcessor(this->pgconn, NULL, NULL);
+	if(this->default_notice_processor == NULL)
+		this->default_notice_processor = PQsetNoticeProcessor(this->pgconn, NULL, NULL);
 
-	old_proc = this->notice_receiver;
+	old_proc = this->notice_processor;
 	if( rb_block_given_p() ) {
 		proc = rb_block_proc();
 		PQsetNoticeProcessor(this->pgconn, gvl_notice_processor_proxy, (void *)self);
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
-		PQsetNoticeProcessor(this->pgconn, default_notice_processor, NULL);
+		PQsetNoticeProcessor(this->pgconn, this->default_notice_processor, NULL);
 	}
 
-	this->notice_receiver = proc;
+	RB_OBJ_WRITE(self, &this->notice_processor, proc);
 	return old_proc;
 }
 
@@ -2888,11 +2934,12 @@ pgconn_sync_set_client_encoding(VALUE self, VALUE str)
 {
 	PGconn *conn = pg_get_pgconn( self );
 
+	rb_check_frozen(self);
 	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;
@@ -3056,7 +3103,7 @@ pgconn_async_get_last_result(VALUE self)
 	VALUE rb_pgresult = Qnil;
 	PGresult *cur, *prev;
 
-  cur = prev = NULL;
+	cur = prev = NULL;
 	for(;;) {
 		int status;
 
@@ -3088,8 +3135,14 @@ pgconn_async_get_last_result(VALUE self)
  *    conn.discard_results()
  *
  * Silently discard any prior query result that application didn't eat.
- * This is done prior of Connection#exec and sibling methods and can
- * be called explicitly when using the async API.
+ * This is internally used prior to Connection#exec and sibling methods.
+ * It doesn't raise an exception on connection errors, but returns +false+ instead.
+ *
+ * Returns:
+ * * +nil+  when the connection is already idle
+ * * +true+  when some results have been discarded
+ * * +false+  when a failure occured and the connection was closed
+ *
  */
 static VALUE
 pgconn_discard_results(VALUE self)
@@ -3097,8 +3150,12 @@ pgconn_discard_results(VALUE self)
 	PGconn *conn = pg_get_pgconn(self);
 	VALUE socket_io;
 
-	if( PQtransactionStatus(conn) == PQTRANS_IDLE ) {
-		return Qnil;
+	switch( PQtransactionStatus(conn) ) {
+		case PQTRANS_IDLE:
+		case PQTRANS_INTRANS:
+		case PQTRANS_INERROR:
+			return Qnil;
+		default:;
 	}
 
 	socket_io = pgconn_socket_io(self);
@@ -3111,10 +3168,21 @@ pgconn_discard_results(VALUE self)
 		* To avoid this call pg_rb_io_wait() and PQconsumeInput() without rb_raise().
 		*/
 		while( gvl_PQisBusy(conn) ){
-			pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
-			if ( PQconsumeInput(conn) == 0 ) {
-				pgconn_close_socket_io(self);
-				return Qfalse;
+			int events;
+
+			switch( PQflush(conn) ) {
+				case 1:
+					events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
+					if (events & PG_RUBY_IO_READABLE){
+						if ( PQconsumeInput(conn) == 0 ) goto error;
+					}
+					break;
+				case 0:
+					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
+					if ( PQconsumeInput(conn) == 0 ) goto error;
+					break;
+				default:
+					goto error;
 			}
 		}
 
@@ -3124,7 +3192,9 @@ pgconn_discard_results(VALUE self)
 		status = PQresultStatus(cur);
 		PQclear(cur);
 		if (status == PGRES_COPY_IN){
-			gvl_PQputCopyEnd(conn, "COPY terminated by new PQexec");
+			while( gvl_PQputCopyEnd(conn, "COPY terminated by new query or discard_results") == 0 ){
+				pgconn_async_flush(self);
+			}
 		}
 		if (status == PGRES_COPY_OUT){
 			for(;;) {
@@ -3133,10 +3203,7 @@ pgconn_discard_results(VALUE self)
 				if( st == 0 ) {
 					/* would block -> wait for readable data */
 					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
-					if ( PQconsumeInput(conn) == 0 ) {
-						pgconn_close_socket_io(self);
-						return Qfalse;
-					}
+					if ( PQconsumeInput(conn) == 0 ) goto error;
 				} else if( st > 0 ) {
 					/* some data retrieved -> discard it */
 					PQfreemem(buffer);
@@ -3149,6 +3216,10 @@ pgconn_discard_results(VALUE self)
 	}
 
 	return Qtrue;
+
+error:
+	pgconn_close_socket_io(self);
+	return Qfalse;
 }
 
 /*
@@ -3525,11 +3596,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;
 }
 
 /*
@@ -3548,11 +3618,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;
 }
 
 
@@ -3572,11 +3641,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;
 }
 
 /*
@@ -3596,11 +3664,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
@@ -3609,6 +3676,14 @@ pgconn_send_flush_request(VALUE self)
  * LARGE OBJECT SUPPORT
  **************************************************************************/
 
+#define BLOCKING_BEGIN(conn) do { \
+	int old_nonblocking = PQisnonblocking(conn); \
+	PQsetnonblocking(conn, 0);
+
+#define BLOCKING_END(th) \
+	PQsetnonblocking(conn, old_nonblocking); \
+} while(0);
+
 /*
  * call-seq:
  *    conn.lo_creat( [mode] ) -> Integer
@@ -3629,9 +3704,12 @@ pgconn_locreat(int argc, VALUE *argv, VALUE self)
 	else
 		mode = NUM2INT(nmode);
 
-	lo_oid = lo_creat(conn, mode);
+	BLOCKING_BEGIN(conn)
+		lo_oid = lo_creat(conn, mode);
+	BLOCKING_END(conn)
+
 	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);
 }
@@ -3652,7 +3730,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);
 }
@@ -3674,9 +3752,12 @@ pgconn_loimport(VALUE self, VALUE filename)
 
 	Check_Type(filename, T_STRING);
 
-	lo_oid = lo_import(conn, StringValueCStr(filename));
+	BLOCKING_BEGIN(conn)
+		lo_oid = lo_import(conn, StringValueCStr(filename));
+	BLOCKING_END(conn)
+
 	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);
 }
@@ -3692,12 +3773,17 @@ pgconn_loexport(VALUE self, VALUE lo_oid, VALUE filename)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	Oid oid;
+	int ret;
 	Check_Type(filename, T_STRING);
 
 	oid = NUM2UINT(lo_oid);
 
-	if (lo_export(conn, oid, StringValueCStr(filename)) < 0) {
-		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
+	BLOCKING_BEGIN(conn)
+		ret = lo_export(conn, oid, StringValueCStr(filename));
+	BLOCKING_END(conn)
+
+	if (ret < 0) {
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 	}
 	return Qnil;
 }
@@ -3727,8 +3813,12 @@ pgconn_loopen(int argc, VALUE *argv, VALUE self)
 	else
 		mode = NUM2INT(nmode);
 
-	if((fd = lo_open(conn, lo_oid, mode)) < 0) {
-		rb_raise(rb_ePGerror, "can't open large object: %s", PQerrorMessage(conn));
+	BLOCKING_BEGIN(conn)
+		fd = lo_open(conn, lo_oid, mode);
+	BLOCKING_END(conn)
+
+	if(fd < 0) {
+		pg_raise_conn_error( rb_ePGerror, self, "can't open large object: %s", PQerrorMessage(conn));
 	}
 	return INT2FIX(fd);
 }
@@ -3750,11 +3840,15 @@ 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));
+	BLOCKING_BEGIN(conn)
+		n = lo_write(conn, fd, StringValuePtr(buffer),
+				RSTRING_LEN(buffer));
+	BLOCKING_END(conn)
+
+	if(n < 0) {
+		pg_raise_conn_error( rb_ePGerror, self, "lo_write failed: %s", PQerrorMessage(conn));
 	}
 
 	return INT2FIX(n);
@@ -3777,16 +3871,17 @@ 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)
+		pg_raise_conn_error( rb_ePGerror, self, "negative length %d given", len);
 
-	if (len < 0){
-		rb_raise(rb_ePGerror,"nagative length %d given", len);
-	}
+	buffer = ALLOC_N(char, len);
+
+	BLOCKING_BEGIN(conn)
+		ret = lo_read(conn, lo_desc, buffer, len);
+	BLOCKING_END(conn)
 
-	if((ret = lo_read(conn, lo_desc, buffer, len)) < 0)
-		rb_raise(rb_ePGerror, "lo_read failed");
+	if(ret < 0)
+		pg_raise_conn_error( rb_ePGerror, self, "lo_read failed");
 
 	if(ret == 0) {
 		xfree(buffer);
@@ -3815,8 +3910,12 @@ pgconn_lolseek(VALUE self, VALUE in_lo_desc, VALUE offset, VALUE whence)
 	int lo_desc = NUM2INT(in_lo_desc);
 	int ret;
 
-	if((ret = lo_lseek(conn, lo_desc, NUM2INT(offset), NUM2INT(whence))) < 0) {
-		rb_raise(rb_ePGerror, "lo_lseek failed");
+	BLOCKING_BEGIN(conn)
+		ret = lo_lseek(conn, lo_desc, NUM2INT(offset), NUM2INT(whence));
+	BLOCKING_END(conn)
+
+	if(ret < 0) {
+		pg_raise_conn_error( rb_ePGerror, self, "lo_lseek failed");
 	}
 
 	return INT2FIX(ret);
@@ -3835,8 +3934,12 @@ pgconn_lotell(VALUE self, VALUE in_lo_desc)
 	PGconn *conn = pg_get_pgconn(self);
 	int lo_desc = NUM2INT(in_lo_desc);
 
-	if((position = lo_tell(conn, lo_desc)) < 0)
-		rb_raise(rb_ePGerror,"lo_tell failed");
+	BLOCKING_BEGIN(conn)
+		position = lo_tell(conn, lo_desc);
+	BLOCKING_END(conn)
+
+	if(position < 0)
+		pg_raise_conn_error( rb_ePGerror, self, "lo_tell failed");
 
 	return INT2FIX(position);
 }
@@ -3853,9 +3956,14 @@ pgconn_lotruncate(VALUE self, VALUE in_lo_desc, VALUE in_len)
 	PGconn *conn = pg_get_pgconn(self);
 	int lo_desc = NUM2INT(in_lo_desc);
 	size_t len = NUM2INT(in_len);
+	int ret;
 
-	if(lo_truncate(conn,lo_desc,len) < 0)
-		rb_raise(rb_ePGerror,"lo_truncate failed");
+	BLOCKING_BEGIN(conn)
+		ret = lo_truncate(conn,lo_desc,len);
+	BLOCKING_END(conn)
+
+	if(ret < 0)
+		pg_raise_conn_error( rb_ePGerror, self, "lo_truncate failed");
 
 	return Qnil;
 }
@@ -3871,9 +3979,14 @@ pgconn_loclose(VALUE self, VALUE in_lo_desc)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int lo_desc = NUM2INT(in_lo_desc);
+	int ret;
 
-	if(lo_close(conn,lo_desc) < 0)
-		rb_raise(rb_ePGerror,"lo_close failed");
+	BLOCKING_BEGIN(conn)
+		ret = lo_close(conn,lo_desc);
+	BLOCKING_END(conn)
+
+	if(ret < 0)
+		pg_raise_conn_error( rb_ePGerror, self, "lo_close failed");
 
 	return Qnil;
 }
@@ -3889,9 +4002,14 @@ pgconn_lounlink(VALUE self, VALUE in_oid)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	Oid oid = NUM2UINT(in_oid);
+	int ret;
 
-	if(lo_unlink(conn,oid) < 0)
-		rb_raise(rb_ePGerror,"lo_unlink failed");
+	BLOCKING_BEGIN(conn)
+		ret = lo_unlink(conn,oid);
+	BLOCKING_END(conn)
+
+	if(ret < 0)
+		pg_raise_conn_error( rb_ePGerror, self, "lo_unlink failed");
 
 	return Qnil;
 }
@@ -3948,6 +4066,7 @@ static VALUE pgconn_external_encoding(VALUE self);
 static VALUE
 pgconn_internal_encoding_set(VALUE self, VALUE enc)
 {
+	rb_check_frozen(self);
 	if (NIL_P(enc)) {
 		pgconn_sync_set_client_encoding( self, rb_usascii_str_new_cstr("SQL_ASCII") );
 		return enc;
@@ -4002,6 +4121,7 @@ pgconn_async_set_client_encoding(VALUE self, VALUE encname)
 {
 	VALUE query_format, query;
 
+	rb_check_frozen(self);
 	Check_Type(encname, T_STRING);
 	query_format = rb_str_new_cstr("set client_encoding to '%s'");
 	query = rb_funcall(query_format, rb_intern("%"), 1, encname);
@@ -4054,6 +4174,7 @@ pgconn_set_default_encoding( VALUE self )
 	rb_encoding *enc;
 	const char *encname;
 
+	rb_check_frozen(self);
 	if (( enc = rb_default_internal_encoding() )) {
 		encname = pg_get_rb_encoding_as_pg_encoding( enc );
 		if ( pgconn_set_client_encoding_async(self, rb_str_new_cstr(encname)) != 0 )
@@ -4083,10 +4204,11 @@ pgconn_type_map_for_queries_set(VALUE self, VALUE typemap)
 	t_typemap *tm;
 	UNUSED(tm);
 
+	rb_check_frozen(self);
 	/* Check type of method param */
 	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
 
-	this->type_map_for_queries = typemap;
+	RB_OBJ_WRITE(self, &this->type_map_for_queries, typemap);
 
 	return typemap;
 }
@@ -4123,8 +4245,9 @@ pgconn_type_map_for_results_set(VALUE self, VALUE typemap)
 	t_typemap *tm;
 	UNUSED(tm);
 
+	rb_check_frozen(self);
 	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
-	this->type_map_for_results = typemap;
+	RB_OBJ_WRITE(self, &this->type_map_for_results, typemap);
 
 	return typemap;
 }
@@ -4162,13 +4285,14 @@ pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE encoder)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
+	rb_check_frozen(self);
 	if( encoder != Qnil ){
 		t_pg_coder *co;
 		UNUSED(co);
 		/* Check argument type */
 		TypedData_Get_Struct(encoder, t_pg_coder, &pg_coder_type, co);
 	}
-	this->encoder_for_put_copy_data = encoder;
+	RB_OBJ_WRITE(self, &this->encoder_for_put_copy_data, encoder);
 
 	return encoder;
 }
@@ -4210,13 +4334,14 @@ pgconn_decoder_for_get_copy_data_set(VALUE self, VALUE decoder)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
+	rb_check_frozen(self);
 	if( decoder != Qnil ){
 		t_pg_coder *co;
 		UNUSED(co);
 		/* Check argument type */
 		TypedData_Get_Struct(decoder, t_pg_coder, &pg_coder_type, co);
 	}
-	this->decoder_for_get_copy_data = decoder;
+	RB_OBJ_WRITE(self, &this->decoder_for_get_copy_data, decoder);
 
 	return decoder;
 }
@@ -4262,6 +4387,7 @@ pgconn_field_name_type_set(VALUE self, VALUE sym)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
+	rb_check_frozen(self);
 	this->flags &= ~PG_RESULT_FIELD_NAMES_MASK;
 	if( sym == sym_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_SYMBOL;
 	else if ( sym == sym_static_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_STATIC_SYMBOL;
@@ -4298,7 +4424,7 @@ pgconn_field_name_type_get(VALUE self)
  * Document-class: PG::Connection
  */
 void
-init_pg_connection()
+init_pg_connection(void)
 {
 	s_id_encode = rb_intern("encode");
 	s_id_autoclose_set = rb_intern("autoclose=");
@@ -4325,6 +4451,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);
 
@@ -4342,6 +4469,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);