pg 1.2.2-x64-mingw32 → 1.3.0.rc3-x64-mingw32

data/ext/pg_connection.c

@@ -12,6 +12,7 @@
 
 VALUE rb_cPGconn;
 static ID s_id_encode;
+static ID s_id_autoclose_set;
 static VALUE sym_type, sym_format, sym_value;
 static VALUE sym_symbol, sym_string, sym_static_symbol;
 
@@ -20,7 +21,9 @@ 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;
 
 /*
  * Global functions
@@ -33,7 +36,7 @@ t_pg_connection *
 pg_get_connection( VALUE self )
 {
 	t_pg_connection *this;
-	Data_Get_Struct( self, t_pg_connection, this);
+	TypedData_Get_Struct( self, t_pg_connection, &pg_connection_type, this);
 
 	return this;
 }
@@ -46,7 +49,7 @@ static t_pg_connection *
 pg_get_connection_safe( VALUE self )
 {
 	t_pg_connection *this;
-	Data_Get_Struct( 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" );
@@ -65,7 +68,7 @@ PGconn *
 pg_get_pgconn( VALUE self )
 {
 	t_pg_connection *this;
-	Data_Get_Struct( 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" );
@@ -145,16 +148,31 @@ static const char *pg_cstr_enc(VALUE str, int enc_idx){
  * GC Mark function
  */
 static void
-pgconn_gc_mark( t_pg_connection *this )
+pgconn_gc_mark( void *_this )
 {
-	rb_gc_mark( this->socket_io );
-	rb_gc_mark( this->notice_receiver );
-	rb_gc_mark( this->notice_processor );
-	rb_gc_mark( this->type_map_for_queries );
-	rb_gc_mark( this->type_map_for_results );
-	rb_gc_mark( this->trace_stream );
-	rb_gc_mark( this->encoder_for_put_copy_data );
-	rb_gc_mark( this->decoder_for_get_copy_data );
+	t_pg_connection *this = (t_pg_connection *)_this;
+	rb_gc_mark_movable( this->socket_io );
+	rb_gc_mark_movable( this->notice_receiver );
+	rb_gc_mark_movable( this->notice_processor );
+	rb_gc_mark_movable( this->type_map_for_queries );
+	rb_gc_mark_movable( this->type_map_for_results );
+	rb_gc_mark_movable( this->trace_stream );
+	rb_gc_mark_movable( this->encoder_for_put_copy_data );
+	rb_gc_mark_movable( this->decoder_for_get_copy_data );
+}
+
+static void
+pgconn_gc_compact( void *_this )
+{
+	t_pg_connection *this = (t_pg_connection *)_this;
+	pg_gc_location( this->socket_io );
+	pg_gc_location( this->notice_receiver );
+	pg_gc_location( this->notice_processor );
+	pg_gc_location( this->type_map_for_queries );
+	pg_gc_location( this->type_map_for_results );
+	pg_gc_location( this->trace_stream );
+	pg_gc_location( this->encoder_for_put_copy_data );
+	pg_gc_location( this->decoder_for_get_copy_data );
 }
 
 
@@ -162,11 +180,15 @@ pgconn_gc_mark( t_pg_connection *this )
  * GC Free function
  */
 static void
-pgconn_gc_free( t_pg_connection *this )
+pgconn_gc_free( void *_this )
 {
+	t_pg_connection *this = (t_pg_connection *)_this;
 #if defined(_WIN32)
-	if ( RTEST(this->socket_io) )
-		rb_w32_unwrap_io_handle( this->ruby_sd );
+	if ( RTEST(this->socket_io) ) {
+		if( rb_w32_unwrap_io_handle(this->ruby_sd) ){
+			rb_warn("pg: Could not unwrap win32 socket handle by garbage collector");
+		}
+	}
 #endif
 	if (this->pgconn != NULL)
 		PQfinish( this->pgconn );
@@ -174,6 +196,29 @@ pgconn_gc_free( t_pg_connection *this )
 	xfree(this);
 }
 
+/*
+ * Object Size function
+ */
+static size_t
+pgconn_memsize( const void *_this )
+{
+	const t_pg_connection *this = (const t_pg_connection *)_this;
+	return sizeof(*this);
+}
+
+static const rb_data_type_t pg_connection_type = {
+	"PG::Connection",
+	{
+		pgconn_gc_mark,
+		pgconn_gc_free,
+		pgconn_memsize,
+		pg_compact_callback(pgconn_gc_compact),
+	},
+	0,
+	0,
+	0,
+};
+
 
 /**************************************************************************
  * Class Methods
@@ -189,7 +234,7 @@ static VALUE
 pgconn_s_allocate( VALUE klass )
 {
 	t_pg_connection *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_connection, pgconn_gc_mark, pgconn_gc_free, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_connection, &pg_connection_type, this );
 
 	this->pgconn = NULL;
 	this->socket_io = Qnil;
@@ -204,65 +249,13 @@ pgconn_s_allocate( VALUE klass )
 	return self;
 }
 
-
-/*
- * Document-method: new
- *
- * call-seq:
- *    PG::Connection.new -> conn
- *    PG::Connection.new(connection_hash) -> conn
- *    PG::Connection.new(connection_string) -> conn
- *    PG::Connection.new(host, port, options, tty, dbname, user, password) ->  conn
- *
- * Create a connection to the specified server.
- *
- * +connection_hash+ must be a ruby Hash with connection parameters.
- * See the {list of valid parameters}[https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PARAMKEYWORDS] in the PostgreSQL documentation.
- *
- * There are two accepted formats for +connection_string+: plain <code>keyword = value</code> strings and URIs.
- * See the documentation of {connection strings}[https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING].
- *
- * The positional parameter form has the same functionality except that the missing parameters will always take on default values. The parameters are:
- * [+host+]
- *   server hostname
- * [+port+]
- *   server port number
- * [+options+]
- *   backend options
- * [+tty+]
- *   (ignored in newer versions of PostgreSQL)
- * [+dbname+]
- *   connecting database name
- * [+user+]
- *   login user name
- * [+password+]
- *   login password
- *
- * Examples:
- *
- *   # Connect using all defaults
- *   PG::Connection.new
- *
- *   # As a Hash
- *   PG::Connection.new( :dbname => 'test', :port => 5432 )
- *
- *   # As a String
- *   PG::Connection.new( "dbname=test port=5432" )
- *
- *   # As an Array
- *   PG::Connection.new( nil, 5432, nil, nil, 'test', nil, nil )
- *
- * If the Ruby default internal encoding is set (i.e., <code>Encoding.default_internal != nil</code>), the
- * connection will have its +client_encoding+ set accordingly.
- *
- * Raises a PG::Error if the connection fails.
- */
 static VALUE
-pgconn_init(int argc, VALUE *argv, VALUE self)
+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 );
 	conninfo = rb_funcall2( rb_cPGconn, rb_intern("parse_connect_args"), argc, argv );
@@ -335,34 +328,14 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	return rb_conn;
 }
 
-/*
- * call-seq:
- *    PG::Connection.ping(connection_hash)       -> Integer
- *    PG::Connection.ping(connection_string)     -> Integer
- *    PG::Connection.ping(host, port, options, tty, dbname, login, password) ->  Integer
- *
- * Check server status.
- *
- * See PG::Connection.new for a description of the parameters.
- *
- * Returns one of:
- * [+PQPING_OK+]
- *   server is accepting connections
- * [+PQPING_REJECT+]
- *   server is alive but rejecting connections
- * [+PQPING_NO_RESPONSE+]
- *   could not establish connection
- * [+PQPING_NO_ATTEMPT+]
- *   connection not attempted (bad params)
- */
 static VALUE
-pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
+pgconn_s_sync_ping( int argc, VALUE *argv, VALUE klass )
 {
 	PGPing ping;
 	VALUE conninfo;
 
 	conninfo = rb_funcall2( klass, rb_intern("parse_connect_args"), argc, argv );
-	ping     = PQping( StringValueCStr(conninfo) );
+	ping     = gvl_PQping( StringValueCStr(conninfo) );
 
 	return INT2FIX((int)ping);
 }
@@ -405,30 +378,8 @@ pgconn_s_conndefaults(VALUE self)
 
 
 #ifdef HAVE_PQENCRYPTPASSWORDCONN
-/*
- * call-seq:
- *    conn.encrypt_password( password, username, algorithm=nil ) -> String
- *
- * This function is intended to be used by client applications that wish to send commands like <tt>ALTER USER joe PASSWORD 'pwd'</tt>.
- * It is good practice not to send the original cleartext password in such a command, because it might be exposed in command logs, activity displays, and so on.
- * Instead, use this function to convert the password to encrypted form before it is sent.
- *
- * The +password+ and +username+ arguments are the cleartext password, and the SQL name of the user it is for.
- * +algorithm+ specifies the encryption algorithm to use to encrypt the password.
- * Currently supported algorithms are +md5+ and +scram-sha-256+ (+on+ and +off+ are also accepted as aliases for +md5+, for compatibility with older server versions).
- * Note that support for +scram-sha-256+ was introduced in PostgreSQL version 10, and will not work correctly with older server versions.
- * If algorithm is omitted or +nil+, this function will query the server for the current value of the +password_encryption+ setting.
- * That can block, and will fail if the current transaction is aborted, or if the connection is busy executing another query.
- * If you wish to use the default algorithm for the server but want to avoid blocking, query +password_encryption+ yourself before calling #encrypt_password, and pass that value as the algorithm.
- *
- * Return value is the encrypted password.
- * The caller can assume the string doesn't contain any special characters that would require escaping.
- *
- * Available since PostgreSQL-10.
- * See also corresponding {libpq function}[https://www.postgresql.org/docs/current/libpq-misc.html#LIBPQ-PQENCRYPTPASSWORDCONN].
- */
 static VALUE
-pgconn_encrypt_password(int argc, VALUE *argv, VALUE self)
+pgconn_sync_encrypt_password(int argc, VALUE *argv, VALUE self)
 {
 	char *encrypted = NULL;
 	VALUE rval = Qnil;
@@ -523,6 +474,11 @@ pgconn_connect_poll(VALUE self)
 {
 	PostgresPollingStatusType status;
 	status = gvl_PQconnectPoll(pg_get_pgconn(self));
+
+	if ( status == PGRES_POLLING_FAILED ) {
+		pgconn_close_socket_io(self);
+	}
+
 	return INT2FIX((int)status);
 }
 
@@ -559,15 +515,8 @@ pgconn_finished_p( VALUE self )
 }
 
 
-/*
- * call-seq:
- *    conn.reset()
- *
- * Resets the backend connection. This method closes the
- * backend connection and tries to re-connect.
- */
 static VALUE
-pgconn_reset( VALUE self )
+pgconn_sync_reset( VALUE self )
 {
 	pgconn_close_socket_io( self );
 	gvl_PQreset( pg_get_pgconn(self) );
@@ -606,6 +555,11 @@ pgconn_reset_poll(VALUE self)
 {
 	PostgresPollingStatusType status;
 	status = gvl_PQresetPoll(pg_get_pgconn(self));
+
+	if ( status == PGRES_POLLING_FAILED ) {
+		pgconn_close_socket_io(self);
+	}
+
 	return INT2FIX((int)status);
 }
 
@@ -676,21 +630,19 @@ static VALUE
 pgconn_port(VALUE self)
 {
 	char* port = PQport(pg_get_pgconn(self));
-	return INT2NUM(atol(port));
+	return INT2NUM(atoi(port));
 }
 
 /*
  * call-seq:
  *    conn.tty()
  *
- * Returns the connected pgtty. (Obsolete)
+ * Obsolete function.
  */
 static VALUE
 pgconn_tty(VALUE self)
 {
-	char *tty = PQtty(pg_get_pgconn(self));
-	if (!tty) return Qnil;
-	return rb_str_new2(tty);
+	return rb_str_new2("");
 }
 
 /*
@@ -708,7 +660,6 @@ pgconn_options(VALUE self)
 }
 
 
-#ifdef HAVE_PQCONNINFO
 /*
  * call-seq:
  *    conn.conninfo   -> hash
@@ -728,14 +679,17 @@ pgconn_conninfo( VALUE self )
 
 	return array;
 }
-#endif
 
 
 /*
  * call-seq:
  *    conn.status()
  *
- * Returns status of connection : CONNECTION_OK or CONNECTION_BAD
+ * Returns the status of the connection, which is one:
+ *   PG::Constants::CONNECTION_OK
+ *   PG::Constants::CONNECTION_BAD
+ *
+ * ... and other constants of kind PG::Constants::CONNECTION_*
  */
 static VALUE
 pgconn_status(VALUE self)
@@ -823,7 +777,10 @@ pgconn_server_version(VALUE self)
  * call-seq:
  *    conn.error_message -> String
  *
- * Returns the error message about connection.
+ * Returns the error message most recently generated by an operation on the connection.
+ *
+ * Nearly all libpq functions will set a message for conn.error_message if they fail.
+ * Note that by libpq convention, a nonempty error_message result can consist of multiple lines, and will include a trailing newline.
  */
 static VALUE
 pgconn_error_message(VALUE self)
@@ -878,8 +835,8 @@ pgconn_socket_io(VALUE self)
 {
 	int sd;
 	int ruby_sd;
-	ID id_autoclose = rb_intern("autoclose=");
 	t_pg_connection *this = pg_get_connection_safe( self );
+	VALUE cSocket;
 	VALUE socket_io = this->socket_io;
 
 	if ( !RTEST(socket_io) ) {
@@ -888,15 +845,19 @@ pgconn_socket_io(VALUE self)
 
 		#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");
+			}
 			this->ruby_sd = ruby_sd;
 		#else
 			ruby_sd = sd;
 		#endif
 
-		socket_io = rb_funcall( rb_cIO, rb_intern("for_fd"), 1, INT2NUM(ruby_sd) );
+		cSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
+		socket_io = rb_funcall( cSocket, rb_intern("for_fd"), 1, INT2NUM(ruby_sd));
 
 		/* Disable autoclose feature */
-		rb_funcall( socket_io, id_autoclose, 1, Qfalse );
+		rb_funcall( socket_io, s_id_autoclose_set, 1, Qfalse );
 
 		this->socket_io = socket_io;
 	}
@@ -918,6 +879,51 @@ pgconn_backend_pid(VALUE self)
 	return INT2NUM(PQbackendPID(pg_get_pgconn(self)));
 }
 
+typedef struct
+{
+	struct sockaddr_storage addr;
+	socklen_t salen;
+} SockAddr;
+
+/* Copy of struct pg_cancel from libpq-int.h
+ *
+ * See https://github.com/postgres/postgres/blame/master/src/interfaces/libpq/libpq-int.h#L577-L586
+ */
+struct pg_cancel
+{
+	SockAddr	raddr;			/* Remote address */
+	int			be_pid;			/* PID of backend --- needed for cancels */
+	int			be_key;			/* key of backend --- needed for cancels */
+};
+
+/*
+ * call-seq:
+ *    conn.backend_key() -> Integer
+ *
+ * Returns the key of the backend server process for this connection.
+ * This key can be used to cancel queries on the server.
+ */
+static VALUE
+pgconn_backend_key(VALUE self)
+{
+	int be_key;
+	struct pg_cancel *cancel;
+	PGconn *conn = pg_get_pgconn(self);
+
+	cancel = (struct pg_cancel*)PQgetCancel(conn);
+	if(cancel == NULL)
+		rb_raise(rb_ePGerror,"Invalid connection!");
+
+	if( cancel->be_pid != PQbackendPID(conn) )
+		rb_raise(rb_ePGerror,"Unexpected binary struct layout - please file a bug report at ruby-pg!");
+
+	be_key = cancel->be_key;
+
+	PQfreeCancel(cancel);
+
+	return INT2NUM(be_key);
+}
+
 /*
  * call-seq:
  *    conn.connection_needs_password() -> Boolean
@@ -948,7 +954,7 @@ pgconn_connection_used_password(VALUE self)
 /* :TODO: get_ssl */
 
 
-static VALUE pgconn_exec_params( int, VALUE *, VALUE );
+static VALUE pgconn_sync_exec_params( int, VALUE *, VALUE );
 
 /*
  * call-seq:
@@ -962,11 +968,11 @@ static VALUE pgconn_exec_params( int, VALUE *, VALUE );
  * However #async_exec has two advantages:
  *
  * 1. #async_exec can be aborted by signals (like Ctrl-C), while #exec blocks signal processing until the query is answered.
- * 2. Ruby VM gets notified about IO blocked operations.
- *    It can therefore schedule things like garbage collection, while queries are running like in this proposal: https://bugs.ruby-lang.org/issues/14723
+ * 2. Ruby VM gets notified about IO blocked operations and can pass them through <tt>Fiber.scheduler</tt>.
+ *    So only <tt>async_*</tt> methods are compatible to event based schedulers like the async gem.
  */
 static VALUE
-pgconn_exec(int argc, VALUE *argv, VALUE self)
+pgconn_sync_exec(int argc, VALUE *argv, VALUE self)
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
 	PGresult *result = NULL;
@@ -987,7 +993,7 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 	pg_deprecated(0, ("forwarding exec to exec_params is deprecated"));
 
 	/* Otherwise, just call #exec_params instead for backward-compatibility */
-	return pgconn_exec_params( argc, argv, self );
+	return pgconn_sync_exec_params( argc, argv, self );
 
 }
 
@@ -1019,7 +1025,7 @@ struct query_params_data {
 	 * Filled by alloc_query_params()
 	 */
 
-	/* Wraps the pointer of allocated memory, if function parameters dont't
+	/* Wraps the pointer of allocated memory, if function parameters don't
 	 * fit in the memory_pool below.
 	 */
 	VALUE heap_pool;
@@ -1037,7 +1043,7 @@ struct query_params_data {
 	Oid *types;
 
 	/* This array takes the string values for the timeframe of the query,
-	 * if param value convertion is required
+	 * if param value conversion is required
 	 */
 	VALUE gc_array;
 
@@ -1051,8 +1057,9 @@ struct query_params_data {
 };
 
 static void
-free_typecast_heap_chain(struct linked_typecast_data *chain_entry)
+free_typecast_heap_chain(void *_chain_entry)
 {
+	struct linked_typecast_data *chain_entry = (struct linked_typecast_data *)_chain_entry;
 	while(chain_entry){
 		struct linked_typecast_data *next = chain_entry->next;
 		xfree(chain_entry);
@@ -1060,6 +1067,18 @@ free_typecast_heap_chain(struct linked_typecast_data *chain_entry)
 	}
 }
 
+static const rb_data_type_t pg_typecast_buffer_type = {
+	"PG::Connection typecast buffer chain",
+	{
+		(RUBY_DATA_FUNC) NULL,
+		free_typecast_heap_chain,
+		(size_t (*)(const void *))NULL,
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static char *
 alloc_typecast_buf( VALUE *typecast_heap_chain, int len )
 {
@@ -1070,17 +1089,28 @@ alloc_typecast_buf( VALUE *typecast_heap_chain, int len )
 	/* Did we already wrap a memory chain per T_DATA object? */
 	if( NIL_P( *typecast_heap_chain ) ){
 		/* Leave free'ing of the buffer chain to the GC, when paramsData has left the stack */
-		*typecast_heap_chain = Data_Wrap_Struct( rb_cObject, NULL, free_typecast_heap_chain, allocated );
+		*typecast_heap_chain = TypedData_Wrap_Struct( rb_cObject, &pg_typecast_buffer_type, allocated );
 		allocated->next = NULL;
 	} else {
 		/* Append to the chain */
-		allocated->next = DATA_PTR( *typecast_heap_chain );
-		DATA_PTR( *typecast_heap_chain ) = allocated;
+		allocated->next = RTYPEDDATA_DATA( *typecast_heap_chain );
+		RTYPEDDATA_DATA( *typecast_heap_chain ) = allocated;
 	}
 
 	return &allocated->data[0];
 }
 
+static const rb_data_type_t pg_query_heap_pool_type = {
+	"PG::Connection query heap pool",
+	{
+		(RUBY_DATA_FUNC) NULL,
+		RUBY_TYPED_DEFAULT_FREE,
+		(size_t (*)(const void *))NULL,
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 static int
 alloc_query_params(struct query_params_data *paramsData)
@@ -1095,7 +1125,7 @@ alloc_query_params(struct query_params_data *paramsData)
 
 	Check_Type(paramsData->params, T_ARRAY);
 
-	p_typemap = DATA_PTR( paramsData->typemap );
+	p_typemap = RTYPEDDATA_DATA( paramsData->typemap );
 	p_typemap->funcs.fit_to_query( paramsData->typemap, paramsData->params );
 
 	paramsData->heap_pool = Qnil;
@@ -1114,7 +1144,7 @@ alloc_query_params(struct query_params_data *paramsData)
 		/* Allocate one combined memory pool for all possible function parameters */
 		memory_pool = (char*)xmalloc( required_pool_size );
 		/* Leave free'ing of the buffer to the GC, when paramsData has left the stack */
-		paramsData->heap_pool = Data_Wrap_Struct( rb_cObject, NULL, -1, memory_pool );
+		paramsData->heap_pool = TypedData_Wrap_Struct( rb_cObject, &pg_query_heap_pool_type, memory_pool );
 		required_pool_size = 0;
 	}else{
 		/* Use stack memory for function parameters */
@@ -1227,12 +1257,11 @@ pgconn_query_assign_typemap( VALUE self, struct query_params_data *paramsData )
 		/* Use default typemap for queries. It's type is checked when assigned. */
 		paramsData->typemap = pg_get_connection(self)->type_map_for_queries;
 	}else{
+		t_typemap *tm;
+		UNUSED(tm);
+
 		/* Check type of method param */
-		if ( !rb_obj_is_kind_of(paramsData->typemap, rb_cTypeMap) ) {
-			rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::TypeMap)",
-					rb_obj_classname( paramsData->typemap ) );
-		}
-		Check_Type( paramsData->typemap, T_DATA );
+		TypedData_Get_Struct(paramsData->typemap, t_typemap, &pg_typemap_type, tm);
 	}
 }
 
@@ -1246,7 +1275,7 @@ pgconn_query_assign_typemap( VALUE self, struct query_params_data *paramsData )
  * It's not recommended to use explicit sync or async variants but #exec_params instead, unless you have a good reason to do so.
  */
 static VALUE
-pgconn_exec_params( int argc, VALUE *argv, VALUE self )
+pgconn_sync_exec_params( int argc, VALUE *argv, VALUE self )
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
 	PGresult *result = NULL;
@@ -1266,7 +1295,7 @@ pgconn_exec_params( int argc, VALUE *argv, VALUE self )
 	 */
 	if ( NIL_P(paramsData.params) ) {
 		pg_deprecated(1, ("forwarding exec_params to exec is deprecated"));
-		return pgconn_exec( 1, argv, self );
+		return pgconn_sync_exec( 1, argv, self );
 	}
 	pgconn_query_assign_typemap( self, &paramsData );
 
@@ -1297,7 +1326,7 @@ pgconn_exec_params( int argc, VALUE *argv, VALUE self )
  * It's not recommended to use explicit sync or async variants but #prepare instead, unless you have a good reason to do so.
  */
 static VALUE
-pgconn_prepare(int argc, VALUE *argv, VALUE self)
+pgconn_sync_prepare(int argc, VALUE *argv, VALUE self)
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
 	PGresult *result = NULL;
@@ -1346,7 +1375,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  * It's not recommended to use explicit sync or async variants but #exec_prepared instead, unless you have a good reason to do so.
  */
 static VALUE
-pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
+pgconn_sync_exec_prepared(int argc, VALUE *argv, VALUE self)
 {
 	t_pg_connection *this = pg_get_connection_safe( self );
 	PGresult *result = NULL;
@@ -1391,7 +1420,7 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
  * It's not recommended to use explicit sync or async variants but #describe_prepared instead, unless you have a good reason to do so.
  */
 static VALUE
-pgconn_describe_prepared(VALUE self, VALUE stmt_name)
+pgconn_sync_describe_prepared(VALUE self, VALUE stmt_name)
 {
 	PGresult *result;
 	VALUE rb_pgresult;
@@ -1419,7 +1448,7 @@ pgconn_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_describe_portal(self, stmt_name)
+pgconn_sync_describe_portal(self, stmt_name)
 	VALUE self, stmt_name;
 {
 	PGresult *result;
@@ -1454,6 +1483,9 @@ pgconn_describe_portal(self, stmt_name)
  * * +PGRES_NONFATAL_ERROR+
  * * +PGRES_FATAL_ERROR+
  * * +PGRES_COPY_BOTH+
+ * * +PGRES_SINGLE_TUPLE+
+ * * +PGRES_PIPELINE_SYNC+
+ * * +PGRES_PIPELINE_ABORTED+
  */
 static VALUE
 pgconn_make_empty_pgresult(VALUE self, VALUE status)
@@ -1750,6 +1782,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 			rb_iv_set(error, "@connection", self);
 			rb_exc_raise(error);
 		}
+		pgconn_wait_for_flush( self );
 		return Qnil;
 	}
 
@@ -1779,7 +1812,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :type => 0, :format => 0 }
  *
- * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
+ * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
  *
@@ -1827,6 +1860,7 @@ pgconn_send_query_params(int argc, VALUE *argv, VALUE self)
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
+	pgconn_wait_for_flush( self );
 	return Qnil;
 }
 
@@ -1847,7 +1881,7 @@ pgconn_send_query_params(int argc, VALUE *argv, VALUE self)
  *
  * For example: "SELECT $1::int"
  *
- * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
+ * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query.
  */
 static VALUE
@@ -1890,6 +1924,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
+	pgconn_wait_for_flush( self );
 	return Qnil;
 }
 
@@ -1911,7 +1946,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :format => 0 }
  *
- * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
+ * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
  *
@@ -1941,7 +1976,6 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 
 	if(NIL_P(paramsData.params)) {
 		paramsData.params = rb_ary_new2(0);
-		resultFormat = 0;
 	}
 	pgconn_query_assign_typemap( self, &paramsData );
 
@@ -1959,6 +1993,7 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
+	pgconn_wait_for_flush( self );
 	return Qnil;
 }
 
@@ -1980,6 +2015,7 @@ pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
+	pgconn_wait_for_flush( self );
 	return Qnil;
 }
 
@@ -2002,28 +2038,13 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
 	}
+	pgconn_wait_for_flush( self );
 	return Qnil;
 }
 
 
-/*
- * call-seq:
- *    conn.get_result() -> PG::Result
- *    conn.get_result() {|pg_result| block }
- *
- * Blocks waiting for the next result from a call to
- * #send_query (or another asynchronous command), and returns
- * it. Returns +nil+ if no more results are available.
- *
- * Note: call this function repeatedly until it returns +nil+, or else
- * you will not be able to issue further commands.
- *
- * 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.
- */
 static VALUE
-pgconn_get_result(VALUE self)
+pgconn_sync_get_result(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	PGresult *result;
@@ -2056,6 +2077,7 @@ pgconn_consume_input(self)
 	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);
@@ -2068,7 +2090,7 @@ pgconn_consume_input(self)
  *    conn.is_busy() -> Boolean
  *
  * Returns +true+ if a command is busy, that is, if
- * PQgetResult would block. Otherwise returns +false+.
+ * #get_result would block. Otherwise returns +false+.
  */
 static VALUE
 pgconn_is_busy(self)
@@ -2077,24 +2099,8 @@ pgconn_is_busy(self)
 	return gvl_PQisBusy(pg_get_pgconn(self)) ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq:
- *    conn.setnonblocking(Boolean) -> nil
- *
- * Sets the nonblocking status of the connection.
- * In the blocking state, calls to #send_query
- * will block until the message is sent to the server,
- * but will not wait for the query results.
- * In the nonblocking state, calls to #send_query
- * will return an error if the socket is not ready for
- * writing.
- * Note: This function does not affect #exec, because
- * that function doesn't return until the server has
- * processed the query and returned the results.
- * Returns +nil+.
- */
 static VALUE
-pgconn_setnonblocking(self, state)
+pgconn_sync_setnonblocking(self, state)
 	VALUE self, state;
 {
 	int arg;
@@ -2116,33 +2122,15 @@ pgconn_setnonblocking(self, state)
 }
 
 
-/*
- * call-seq:
- *    conn.isnonblocking() -> Boolean
- *
- * Returns +true+ if a command is busy, that is, if
- * PQgetResult would block. Otherwise returns +false+.
- */
 static VALUE
-pgconn_isnonblocking(self)
+pgconn_sync_isnonblocking(self)
 	VALUE self;
 {
 	return PQisnonblocking(pg_get_pgconn(self)) ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq:
- *    conn.flush() -> Boolean
- *
- * 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.
- * Raises PG::Error if some other failure occurred.
- */
 static VALUE
-pgconn_flush(self)
-	VALUE self;
+pgconn_sync_flush(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int ret;
@@ -2156,18 +2144,8 @@ pgconn_flush(self)
 	return (ret) ? Qfalse : Qtrue;
 }
 
-/*
- * call-seq:
- *    conn.cancel() -> String
- *
- * Requests cancellation of the command currently being
- * processed. (Only implemented in PostgreSQL >= 8.0)
- *
- * Returns +nil+ on success, or a string containing the
- * error message if a failure occurs.
- */
 static VALUE
-pgconn_cancel(VALUE self)
+pgconn_sync_cancel(VALUE self)
 {
 	char errbuf[256];
 	PGcancel *cancel;
@@ -2178,7 +2156,7 @@ pgconn_cancel(VALUE self)
 	if(cancel == NULL)
 		rb_raise(rb_ePGerror,"Invalid connection!");
 
-	ret = gvl_PQcancel(cancel, errbuf, 256);
+	ret = gvl_PQcancel(cancel, errbuf, sizeof(errbuf));
 	if(ret == 1)
 		retval = Qnil;
 	else
@@ -2229,107 +2207,58 @@ pgconn_notifies(VALUE self)
 	return hash;
 }
 
-/* Win32 + Ruby 1.9+ */
-#if defined( _WIN32 )
-/*
- * On Windows, use platform-specific strategies to wait for the socket
- * instead of rb_wait_for_single_fd().
- */
 
-int rb_w32_wait_events( HANDLE *events, int num, DWORD timeout );
+#if defined(HAVE_RB_IO_WAIT)
 
-static void *
-wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readable)(PGconn *) )
-{
-	int sd = PQsocket( conn );
-	void *retval;
-	struct timeval aborttime={0,0}, currtime, waittime;
-	DWORD timeout_milisec = INFINITE;
-	DWORD wait_ret;
-	WSAEVENT hEvent;
-
-	if ( sd < 0 )
-		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
-
-	hEvent = WSACreateEvent();
-
-	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if( PQconsumeInput(conn) == 0 ) {
-		WSACloseEvent( hEvent );
-		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
-	}
-
-	if ( ptimeout ) {
-		gettimeofday(&currtime, NULL);
-		timeradd(&currtime, ptimeout, &aborttime);
-	}
+/* Use our own function and constants names, to avoid conflicts with truffleruby-head on its road to ruby-3.0 compatibility. */
+#define pg_rb_io_wait rb_io_wait
+#define PG_RUBY_IO_READABLE RUBY_IO_READABLE
+#define PG_RUBY_IO_WRITABLE RUBY_IO_WRITABLE
+#define PG_RUBY_IO_PRIORITY RUBY_IO_PRIORITY
 
-	while ( !(retval=is_readable(conn)) ) {
-		if ( WSAEventSelect(sd, hEvent, FD_READ|FD_CLOSE) == SOCKET_ERROR ) {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_eConnectionBad, "WSAEventSelect socket error: %d", WSAGetLastError() );
-		}
-
-		if ( ptimeout ) {
-			gettimeofday(&currtime, NULL);
-			timersub(&aborttime, &currtime, &waittime);
-			timeout_milisec = (DWORD)( waittime.tv_sec * 1e3 + waittime.tv_usec / 1e3 );
-		}
-
-		/* Is the given timeout valid? */
-		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
-			/* Wait for the socket to become readable before checking again */
-			wait_ret = rb_w32_wait_events( &hEvent, 1, timeout_milisec );
-		} else {
-			wait_ret = WAIT_TIMEOUT;
-		}
+#else
+/* For compat with ruby < 3.0 */
 
-		if ( wait_ret == WAIT_TIMEOUT ) {
-			WSACloseEvent( hEvent );
-			return NULL;
-		} else if ( wait_ret == WAIT_OBJECT_0 ) {
-			/* The event we were waiting for. */
-		} else if ( wait_ret == WAIT_OBJECT_0 + 1) {
-			/* This indicates interruption from timer thread, GC, exception
-			 * from other threads etc... */
-			rb_thread_check_ints();
-		} else if ( wait_ret == WAIT_FAILED ) {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_eConnectionBad, "Wait on socket error (WaitForMultipleObjects): %lu", GetLastError() );
-		} else {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_eConnectionBad, "Wait on socket abandoned (WaitForMultipleObjects)" );
-		}
+typedef enum {
+    PG_RUBY_IO_READABLE = RB_WAITFD_IN,
+    PG_RUBY_IO_WRITABLE = RB_WAITFD_OUT,
+    PG_RUBY_IO_PRIORITY = RB_WAITFD_PRI,
+} pg_rb_io_event_t;
 
-		/* Check for connection errors (PQisBusy is true on connection errors) */
-		if ( PQconsumeInput(conn) == 0 ) {
-			WSACloseEvent( hEvent );
-			rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
-		}
+static VALUE
+pg_rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
+	rb_io_t *fptr;
+	struct timeval waittime;
+	int res;
+
+	GetOpenFile((io), fptr);
+	if( !NIL_P(timeout) ){
+		waittime.tv_sec = (time_t)(NUM2DBL(timeout));
+		waittime.tv_usec = (time_t)(NUM2DBL(timeout) - (double)waittime.tv_sec);
 	}
+	res = rb_wait_for_single_fd(fptr->fd, NUM2UINT(events), NIL_P(timeout) ? NULL : &waittime);
 
-	WSACloseEvent( hEvent );
-	return retval;
+	return UINT2NUM(res);
 }
-
-#else
-
-/* non Win32 */
+#endif
 
 static void *
-wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
+wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
 {
-	int sd = PQsocket( conn );
-	int ret;
+	VALUE socket_io;
+	VALUE ret;
 	void *retval;
 	struct timeval aborttime={0,0}, currtime, waittime;
+	VALUE wait_timeout = Qnil;
+	PGconn *conn = pg_get_pgconn(self);
 
-	if ( sd < 0 )
-		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
+	socket_io = pgconn_socket_io(self);
 
 	/* Check for connection errors (PQisBusy is true on connection errors) */
-	if ( PQconsumeInput(conn) == 0 )
+	if ( PQconsumeInput(conn) == 0 ) {
+		pgconn_close_socket_io(self);
 		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
+	}
 
 	if ( ptimeout ) {
 		gettimeofday(&currtime, NULL);
@@ -2340,27 +2269,25 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 		if ( ptimeout ) {
 			gettimeofday(&currtime, NULL);
 			timersub(&aborttime, &currtime, &waittime);
+			wait_timeout = DBL2NUM((double)(waittime.tv_sec) + (double)(waittime.tv_usec) / 1000000.0);
 		}
 
 		/* Is the given timeout valid? */
 		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
 			/* Wait for the socket to become readable before checking again */
-			ret = rb_wait_for_single_fd( sd, RB_WAITFD_IN, ptimeout ? &waittime : NULL );
+			ret = pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), wait_timeout);
 		} else {
-			ret = 0;
-		}
-
-		if ( ret < 0 ){
-			rb_sys_fail( "rb_wait_for_single_fd()" );
+			ret = Qfalse;
 		}
 
 		/* Return false if the select() timed out */
-		if ( ret == 0 ){
+		if ( ret == Qfalse ){
 			return NULL;
 		}
 
 		/* 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) );
 		}
 	}
@@ -2368,8 +2295,45 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 	return retval;
 }
 
+/*
+ * call-seq:
+ *    conn.flush() -> Boolean
+ *
+ * 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.
+ * Raises PG::Error if some other failure occurred.
+ */
+static VALUE
+pgconn_async_flush(VALUE self)
+{
+	while( pgconn_sync_flush(self) == Qfalse ){
+		/* wait for the socket to become read- or write-ready */
+		int events;
+		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)
+			pgconn_consume_input(self);
+	}
+	return Qtrue;
+}
+
+static VALUE
+pgconn_wait_for_flush( VALUE self ){
+	if( !pg_get_connection_safe(self)->flush_data )
+		return Qnil;
 
-#endif
+	return pgconn_async_flush(self);
+}
+
+static VALUE
+pgconn_flush_data_set( VALUE self, VALUE enabled ){
+	t_pg_connection *conn = pg_get_connection(self);
+	conn->flush_data = RTEST(enabled);
+	return enabled;
+}
 
 static void *
 notify_readable(PGconn *conn)
@@ -2408,7 +2372,7 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 		ptimeout = &timeout;
 	}
 
-	pnotification = (PGnotify*) wait_socket_readable( this->pgconn, ptimeout, notify_readable);
+	pnotification = (PGnotify*) wait_socket_readable( self, ptimeout, notify_readable);
 
 	/* Return nil if the select timed out */
 	if ( !pnotification ) return Qnil;
@@ -2429,28 +2393,8 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 }
 
 
-/*
- * call-seq:
- *    conn.put_copy_data( buffer [, encoder] ) -> Boolean
- *
- * Transmits _buffer_ as copy data to the server.
- * Returns true if the data was sent, false if it was
- * not sent (false is only possible if the connection
- * is in nonblocking mode, and this command would block).
- *
- * _encoder_ can be a PG::Coder derivation (typically PG::TextEncoder::CopyRow).
- * This encodes the data fields given as _buffer_ from an Array of Strings to
- * PostgreSQL's COPY text format inclusive proper escaping. Optionally
- * the encoder can type cast the fields from various Ruby types in one step,
- * if PG::TextEncoder::CopyRow#type_map is set accordingly.
- *
- * Raises an exception if an error occurs.
- *
- * See also #copy_data.
- *
- */
 static VALUE
-pgconn_put_copy_data(int argc, VALUE *argv, VALUE self)
+pgconn_sync_put_copy_data(int argc, VALUE *argv, VALUE self)
 {
 	int ret;
 	int len;
@@ -2467,13 +2411,11 @@ pgconn_put_copy_data(int argc, VALUE *argv, VALUE self)
 		if( NIL_P(this->encoder_for_put_copy_data) ){
 			buffer = value;
 		} else {
-			p_coder = DATA_PTR( this->encoder_for_put_copy_data );
+			p_coder = RTYPEDDATA_DATA( this->encoder_for_put_copy_data );
 		}
-	} else if( rb_obj_is_kind_of(encoder, rb_cPG_Coder) ) {
-		Data_Get_Struct( encoder, t_pg_coder, p_coder );
 	} else {
-		rb_raise( rb_eTypeError, "wrong encoder type %s (expected some kind of PG::Coder)",
-				rb_obj_classname( encoder ) );
+		/* Check argument type and use argument encoder */
+		TypedData_Get_Struct(encoder, t_pg_coder, &pg_coder_type, p_coder);
 	}
 
 	if( p_coder ){
@@ -2507,22 +2449,8 @@ pgconn_put_copy_data(int argc, VALUE *argv, VALUE self)
 	return (ret) ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq:
- *    conn.put_copy_end( [ error_message ] ) -> Boolean
- *
- * Sends end-of-data indication to the server.
- *
- * _error_message_ is an optional parameter, and if set,
- * forces the COPY command to fail with the string
- * _error_message_.
- *
- * Returns true if the end-of-data was sent, false if it was
- * not sent (false is only possible if the connection
- * is in nonblocking mode, and this command would block).
- */
 static VALUE
-pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
+pgconn_sync_put_copy_end(int argc, VALUE *argv, VALUE self)
 {
 	VALUE str;
 	VALUE error;
@@ -2544,27 +2472,8 @@ pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
 	return (ret) ? Qtrue : Qfalse;
 }
 
-/*
- * call-seq:
- *    conn.get_copy_data( [ async = false [, decoder = nil ]] ) -> Object
- *
- * Return one row of data, +nil+
- * if the copy is done, or +false+ if the call would
- * block (only possible if _async_ is true).
- *
- * If _decoder_ is not set or +nil+, data is returned as binary string.
- *
- * If _decoder_ is set to a PG::Coder derivation, the return type depends on this decoder.
- * PG::TextDecoder::CopyRow decodes the received data fields from one row of PostgreSQL's
- * COPY text format to an Array of Strings.
- * Optionally the decoder can type cast the single fields to various Ruby types in one step,
- * if PG::TextDecoder::CopyRow#type_map is set accordingly.
- *
- * See also #copy_data.
- *
- */
 static VALUE
-pgconn_get_copy_data(int argc, VALUE *argv, VALUE self )
+pgconn_sync_get_copy_data(int argc, VALUE *argv, VALUE self )
 {
 	VALUE async_in;
 	VALUE error;
@@ -2579,13 +2488,11 @@ pgconn_get_copy_data(int argc, VALUE *argv, VALUE self )
 
 	if( NIL_P(decoder) ){
 		if( !NIL_P(this->decoder_for_get_copy_data) ){
-			p_coder = DATA_PTR( this->decoder_for_get_copy_data );
+			p_coder = RTYPEDDATA_DATA( this->decoder_for_get_copy_data );
 		}
-	} else if( rb_obj_is_kind_of(decoder, rb_cPG_Coder) ) {
-		Data_Get_Struct( decoder, t_pg_coder, p_coder );
 	} else {
-		rb_raise( rb_eTypeError, "wrong decoder type %s (expected some kind of PG::Coder)",
-				rb_obj_classname( decoder ) );
+		/* Check argument type and use argument decoder */
+		TypedData_Get_Struct(decoder, t_pg_coder, &pg_coder_type, p_coder);
 	}
 
 	ret = gvl_PQgetCopyData(this->pgconn, &buffer, RTEST(async_in));
@@ -2830,7 +2737,7 @@ notice_processor_proxy(void *arg, const char *message)
  * call-seq:
  *   conn.set_notice_processor {|message| ... } -> Proc
  *
- * See #set_notice_receiver for the desription of what this and the
+ * See #set_notice_receiver for the description of what this and the
  * notice_processor methods do.
  *
  * This function takes a new block to act as the notice processor and returns
@@ -2884,12 +2791,14 @@ pgconn_get_client_encoding(VALUE self)
 
 /*
  * call-seq:
- *    conn.set_client_encoding( encoding )
+ *    conn.sync_set_client_encoding( encoding )
  *
- * Sets the client encoding to the _encoding_ String.
+ * This function has the same behavior as #async_set_client_encoding, but is implemented using the synchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ * It's not recommended to use explicit sync or async variants but #set_client_encoding instead, unless you have a good reason to do so.
  */
 static VALUE
-pgconn_set_client_encoding(VALUE self, VALUE str)
+pgconn_sync_set_client_encoding(VALUE self, VALUE str)
 {
 	PGconn *conn = pg_get_pgconn( self );
 
@@ -2903,49 +2812,6 @@ pgconn_set_client_encoding(VALUE self, VALUE str)
 	return Qnil;
 }
 
-/*
- * call-seq:
- *    conn.transaction { |conn| ... } -> result of the block
- *
- * Executes a +BEGIN+ at the start of the block,
- * and a +COMMIT+ at the end of the block, or
- * +ROLLBACK+ if any exception occurs.
- */
-static VALUE
-pgconn_transaction(VALUE self)
-{
-	PGconn *conn = pg_get_pgconn(self);
-	PGresult *result;
-	VALUE rb_pgresult;
-	VALUE block_result = Qnil;
-	int status;
-
-	if (rb_block_given_p()) {
-		result = gvl_PQexec(conn, "BEGIN");
-		rb_pgresult = pg_new_result(result, self);
-		pg_result_check(rb_pgresult);
-		block_result = rb_protect(rb_yield, self, &status);
-		if(status == 0) {
-			result = gvl_PQexec(conn, "COMMIT");
-			rb_pgresult = pg_new_result(result, self);
-			pg_result_check(rb_pgresult);
-		}
-		else {
-			/* exception occurred, ROLLBACK and re-raise */
-			result = gvl_PQexec(conn, "ROLLBACK");
-			rb_pgresult = pg_new_result(result, self);
-			pg_result_check(rb_pgresult);
-			rb_jump_tag(status);
-		}
-
-	}
-	else {
-		/* no block supplied? */
-		rb_raise(rb_eArgError, "Must supply block for PG::Connection#transaction");
-	}
-	return block_result;
-}
-
 
 /*
  * call-seq:
@@ -3022,8 +2888,6 @@ get_result_readable(PGconn *conn)
  */
 static VALUE
 pgconn_block( int argc, VALUE *argv, VALUE self ) {
-	PGconn *conn = pg_get_pgconn( self );
-
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
 	VALUE timeout_in;
@@ -3037,7 +2901,7 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
 		ptimeout = &timeout;
 	}
 
-	ret = wait_socket_readable( conn, ptimeout, get_result_readable);
+	ret = wait_socket_readable( self, ptimeout, get_result_readable);
 
 	if( !ret )
 		return Qfalse;
@@ -3046,6 +2910,42 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
 }
 
 
+/*
+ * call-seq:
+ *    conn.sync_get_last_result( ) -> PG::Result
+ *
+ * This function has the same behavior as #async_get_last_result, but is implemented using the synchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ * It's not recommended to use explicit sync or async variants but #get_last_result instead, unless you have a good reason to do so.
+ */
+static VALUE
+pgconn_sync_get_last_result(VALUE self)
+{
+	PGconn *conn = pg_get_pgconn(self);
+	VALUE rb_pgresult = Qnil;
+	PGresult *cur, *prev;
+
+
+	cur = prev = NULL;
+	while ((cur = gvl_PQgetResult(conn)) != NULL) {
+		int status;
+
+		if (prev) PQclear(prev);
+		prev = cur;
+
+		status = PQresultStatus(cur);
+		if (status == PGRES_COPY_OUT || status == PGRES_COPY_IN || status == PGRES_COPY_BOTH)
+			break;
+	}
+
+	if (prev) {
+		rb_pgresult = pg_new_result( prev, self );
+		pg_result_check(rb_pgresult);
+	}
+
+	return rb_pgresult;
+}
+
 /*
  * call-seq:
  *    conn.get_last_result( ) -> PG::Result
@@ -3056,27 +2956,35 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
  * returns the last non-NULL result, or +nil+ if no
  * results are available.
  *
+ * If the last result contains a bad result_status, an
+ * appropriate exception is raised.
+ *
  * This function is similar to #get_result
  * except that it is designed to get one and only
- * one result.
+ * one result and that it checks the result state.
  */
 static VALUE
-pgconn_get_last_result(VALUE self)
+pgconn_async_get_last_result(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	VALUE rb_pgresult = Qnil;
 	PGresult *cur, *prev;
 
-
-	cur = prev = NULL;
-	while ((cur = gvl_PQgetResult(conn)) != NULL) {
+  cur = prev = NULL;
+	for(;;) {
 		int status;
 
+		pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
+
+		cur = gvl_PQgetResult(conn);
+		if (cur == NULL)
+			break;
+
 		if (prev) PQclear(prev);
 		prev = cur;
 
 		status = PQresultStatus(cur);
-		if (status == PGRES_COPY_OUT || status == PGRES_COPY_IN)
+		if (status == PGRES_COPY_OUT || status == PGRES_COPY_IN || status == PGRES_COPY_BOTH)
 			break;
 	}
 
@@ -3100,22 +3008,60 @@ static VALUE
 pgconn_discard_results(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
+	VALUE socket_io;
 
-	PGresult *cur;
-	while ((cur = gvl_PQgetResult(conn)) != NULL) {
-		int status = PQresultStatus(cur);
+	if( PQtransactionStatus(conn) == PQTRANS_IDLE ) {
+		return Qnil;
+	}
+
+	socket_io = pgconn_socket_io(self);
+
+	for(;;) {
+		PGresult *cur;
+		int status;
+
+		/* pgconn_block() raises an exception in case of errors.
+		* 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;
+			}
+		}
+
+		cur = gvl_PQgetResult(conn);
+		if( cur == NULL) break;
+
+		status = PQresultStatus(cur);
 		PQclear(cur);
 		if (status == PGRES_COPY_IN){
 			gvl_PQputCopyEnd(conn, "COPY terminated by new PQexec");
 		}
 		if (status == PGRES_COPY_OUT){
-			char *buffer = NULL;
-			while( gvl_PQgetCopyData(conn, &buffer, 0) > 0)
-				PQfreemem(buffer);
+			for(;;) {
+				char *buffer = NULL;
+				int st = gvl_PQgetCopyData(conn, &buffer, 1);
+				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;
+					}
+				} else if( st > 0 ) {
+					/* some data retrieved -> discard it */
+					PQfreemem(buffer);
+				} else {
+					/* no more data */
+					break;
+				}
+			}
 		}
 	}
 
-	return Qnil;
+	return Qtrue;
 }
 
 /*
@@ -3138,6 +3084,7 @@ pgconn_discard_results(VALUE self)
  * #exec is an alias for #async_exec which is almost identical to #sync_exec .
  * #sync_exec is implemented on the simpler synchronous command processing API of libpq, whereas
  * #async_exec is implemented on the asynchronous API and on ruby's IO mechanisms.
+ * Only #async_exec is compatible to <tt>Fiber.scheduler</tt> based asynchronous IO processing introduced in ruby-3.0.
  * Both methods ensure that other threads can process while waiting for the server to
  * complete the request, but #sync_exec blocks all signals to be processed until the query is finished.
  * This is most notably visible by a delayed reaction to Control+C.
@@ -3152,8 +3099,7 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 
 	pgconn_discard_results( self );
 	pgconn_send_query( argc, argv, self );
-	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
-	rb_pgresult = pgconn_get_last_result( self );
+	rb_pgresult = pgconn_async_get_last_result( self );
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
@@ -3182,7 +3128,7 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :type => 0, :format => 0 }
  *
- * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
+ * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
  *
@@ -3225,8 +3171,7 @@ pgconn_async_exec_params(int argc, VALUE *argv, VALUE self)
 	} else {
 		pgconn_send_query_params( argc, argv, self );
 	}
-	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
-	rb_pgresult = pgconn_get_last_result( self );
+	rb_pgresult = pgconn_async_get_last_result( self );
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
@@ -3252,7 +3197,7 @@ pgconn_async_exec_params(int argc, VALUE *argv, VALUE self)
  *
  * For example: "SELECT $1::int"
  *
- * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
+ * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query.
  *
  * See also corresponding {libpq function}[https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-PQPREPARE].
@@ -3264,8 +3209,7 @@ pgconn_async_prepare(int argc, VALUE *argv, VALUE self)
 
 	pgconn_discard_results( self );
 	pgconn_send_prepare( argc, argv, self );
-	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
-	rb_pgresult = pgconn_get_last_result( self );
+	rb_pgresult = pgconn_async_get_last_result( self );
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
@@ -3292,7 +3236,7 @@ pgconn_async_prepare(int argc, VALUE *argv, VALUE self)
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :format => 0 }
  *
- * PostgreSQL bind parameters are represented as $1, $1, $2, etc.,
+ * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
  * to $1, the 1st element is bound to $2, etc. +nil+ is treated as +NULL+.
  *
@@ -3318,8 +3262,7 @@ pgconn_async_exec_prepared(int argc, VALUE *argv, VALUE self)
 
 	pgconn_discard_results( self );
 	pgconn_send_query_prepared( argc, argv, self );
-	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
-	rb_pgresult = pgconn_get_last_result( self );
+	rb_pgresult = pgconn_async_get_last_result( self );
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
@@ -3343,8 +3286,7 @@ pgconn_async_describe_portal(VALUE self, VALUE portal)
 
 	pgconn_discard_results( self );
 	pgconn_send_describe_portal( self, portal );
-	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
-	rb_pgresult = pgconn_get_last_result( self );
+	rb_pgresult = pgconn_async_get_last_result( self );
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
@@ -3368,8 +3310,7 @@ pgconn_async_describe_prepared(VALUE self, VALUE stmt_name)
 
 	pgconn_discard_results( self );
 	pgconn_send_describe_prepared( self, stmt_name );
-	pgconn_block( 0, NULL, self ); /* wait for input (without blocking) before reading the last result */
-	rb_pgresult = pgconn_get_last_result( self );
+	rb_pgresult = pgconn_async_get_last_result( self );
 
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
@@ -3457,6 +3398,126 @@ pgconn_ssl_attribute_names(VALUE self)
 #endif
 
 
+#ifdef HAVE_PQENTERPIPELINEMODE
+/*
+ * call-seq:
+ *    conn.pipeline_status -> Integer
+ *
+ * Returns the current pipeline mode status of the libpq connection.
+ *
+ * PQpipelineStatus can return one of the following values:
+ *
+ * * PQ_PIPELINE_ON - The libpq connection is in pipeline mode.
+ * * PQ_PIPELINE_OFF - The libpq connection is not in pipeline mode.
+ * * PQ_PIPELINE_ABORTED - The libpq connection is in pipeline mode and an error occurred while processing the current pipeline.
+ *   The aborted flag is cleared when PQgetResult returns a result of type PGRES_PIPELINE_SYNC.
+ *
+ * Available since PostgreSQL-14
+ */
+static VALUE
+pgconn_pipeline_status(VALUE self)
+{
+	int res = PQpipelineStatus(pg_get_pgconn(self));
+	return INT2FIX(res);
+}
+
+
+/*
+ * call-seq:
+ *    conn.enter_pipeline_mode -> nil
+ *
+ * Causes a connection to enter pipeline mode if it is currently idle or already in pipeline mode.
+ *
+ * Raises PG::Error and has no effect if the connection is not currently idle, i.e., it has a result ready, or it is waiting for more input from the server, etc.
+ * This function does not actually send anything to the server, it just changes the libpq connection state.
+ *
+ * Available since PostgreSQL-14
+ */
+static VALUE
+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));
+	}
+}
+
+/*
+ * call-seq:
+ *    conn.exit_pipeline_mode -> nil
+ *
+ * Causes a connection to exit pipeline mode if it is currently in pipeline mode with an empty queue and no pending results.
+ *
+ * Takes no action if not in pipeline mode.
+ * Raises PG::Error if the current statement isn't finished processing, or PQgetResult has not been called to collect results from all previously sent query.
+ *
+ * Available since PostgreSQL-14
+ */
+static VALUE
+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));
+	}
+}
+
+
+/*
+ * call-seq:
+ *    conn.pipeline_sync -> nil
+ *
+ * Marks a synchronization point in a pipeline by sending a sync message and flushing the send buffer.
+ * This serves as the delimiter of an implicit transaction and an error recovery point; see Section 34.5.1.3 of the PostgreSQL documentation.
+ *
+ * Raises PG::Error if the connection is not in pipeline mode or sending a sync message failed.
+ *
+ * Available since PostgreSQL-14
+ */
+static VALUE
+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));
+	}
+}
+
+/*
+ * call-seq:
+ *    conn.pipeline_sync -> nil
+ *
+ * Sends a request for the server to flush its output buffer.
+ *
+ * The server flushes its output buffer automatically as a result of Connection#pipeline_sync being called, or on any request when not in pipeline mode.
+ * This function is useful to cause the server to flush its output buffer in pipeline mode without establishing a synchronization point.
+ * Note that the request is not itself flushed to the server automatically; use Connection#flush if necessary.
+ *
+ * Available since PostgreSQL-14
+ */
+static VALUE
+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));
+	}
+}
+
+#endif
+
 /**************************************************************************
  * LARGE OBJECT SUPPORT
  **************************************************************************/
@@ -3801,11 +3862,11 @@ static VALUE
 pgconn_internal_encoding_set(VALUE self, VALUE enc)
 {
 	if (NIL_P(enc)) {
-		pgconn_set_client_encoding( self, rb_usascii_str_new_cstr("SQL_ASCII") );
+		pgconn_sync_set_client_encoding( self, rb_usascii_str_new_cstr("SQL_ASCII") );
 		return enc;
 	}
 	else if ( TYPE(enc) == T_STRING && strcasecmp("JOHAB", StringValueCStr(enc)) == 0 ) {
-		pgconn_set_client_encoding(self, rb_usascii_str_new_cstr("JOHAB"));
+		pgconn_sync_set_client_encoding(self, rb_usascii_str_new_cstr("JOHAB"));
 		return enc;
 	}
 	else {
@@ -3843,16 +3904,33 @@ pgconn_external_encoding(VALUE self)
 	return rb_enc_from_encoding( enc );
 }
 
+/*
+ * call-seq:
+ *    conn.set_client_encoding( encoding )
+ *
+ * Sets the client encoding to the _encoding_ String.
+ */
+static VALUE
+pgconn_async_set_client_encoding(VALUE self, VALUE encname)
+{
+	VALUE query_format, query;
+
+	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);
+
+	pgconn_async_exec(1, &query, self);
+	pgconn_set_internal_encoding_index( self );
+
+	return Qnil;
+}
 
 static VALUE
 pgconn_set_client_encoding_async1( VALUE args )
 {
 	VALUE self = ((VALUE*)args)[0];
 	VALUE encname = ((VALUE*)args)[1];
-	VALUE query_format = rb_str_new_cstr("set client_encoding to '%s'");
-	VALUE query = rb_funcall(query_format, rb_intern("%"), 1, encname);
-
-	pgconn_async_exec(1, &query, self);
+	pgconn_async_set_client_encoding(self, encname);
 	return 0;
 }
 
@@ -3867,9 +3945,9 @@ pgconn_set_client_encoding_async2( VALUE arg, VALUE ex )
 
 
 static VALUE
-pgconn_set_client_encoding_async( VALUE self, const char *encname )
+pgconn_set_client_encoding_async( VALUE self, VALUE encname )
 {
-	VALUE args[] = { self, rb_str_new_cstr(encname) };
+	VALUE args[] = { self, encname };
 	return rb_rescue(pgconn_set_client_encoding_async1, (VALUE)&args, pgconn_set_client_encoding_async2, Qnil);
 }
 
@@ -3891,10 +3969,9 @@ pgconn_set_default_encoding( VALUE self )
 
 	if (( enc = rb_default_internal_encoding() )) {
 		encname = pg_get_rb_encoding_as_pg_encoding( enc );
-		if ( pgconn_set_client_encoding_async(self, encname) != 0 )
+		if ( pgconn_set_client_encoding_async(self, rb_str_new_cstr(encname)) != 0 )
 			rb_warning( "Failed to set the default_internal encoding to %s: '%s'",
 			         encname, PQerrorMessage(conn) );
-		pgconn_set_internal_encoding_index( self );
 		return rb_enc_from_encoding( enc );
 	} else {
 		pgconn_set_internal_encoding_index( self );
@@ -3916,12 +3993,12 @@ static VALUE
 pgconn_type_map_for_queries_set(VALUE self, VALUE typemap)
 {
 	t_pg_connection *this = pg_get_connection( self );
+	t_typemap *tm;
+	UNUSED(tm);
+
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
 
-	if ( !rb_obj_is_kind_of(typemap, rb_cTypeMap) ) {
-		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::TypeMap)",
-				rb_obj_classname( typemap ) );
-	}
-	Check_Type(typemap, T_DATA);
 	this->type_map_for_queries = typemap;
 
 	return typemap;
@@ -3956,12 +4033,10 @@ static VALUE
 pgconn_type_map_for_results_set(VALUE self, VALUE typemap)
 {
 	t_pg_connection *this = pg_get_connection( self );
+	t_typemap *tm;
+	UNUSED(tm);
 
-	if ( !rb_obj_is_kind_of(typemap, rb_cTypeMap) ) {
-		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::TypeMap)",
-				rb_obj_classname( typemap ) );
-	}
-	Check_Type(typemap, T_DATA);
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
 	this->type_map_for_results = typemap;
 
 	return typemap;
@@ -3996,20 +4071,19 @@ pgconn_type_map_for_results_get(VALUE self)
  *
  */
 static VALUE
-pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE typemap)
+pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE encoder)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
-	if( typemap != Qnil ){
-		if ( !rb_obj_is_kind_of(typemap, rb_cPG_Coder) ) {
-			rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::Coder)",
-					rb_obj_classname( typemap ) );
-		}
-		Check_Type(typemap, T_DATA);
+	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 = typemap;
+	this->encoder_for_put_copy_data = encoder;
 
-	return typemap;
+	return encoder;
 }
 
 /*
@@ -4045,20 +4119,19 @@ pgconn_encoder_for_put_copy_data_get(VALUE self)
  *
  */
 static VALUE
-pgconn_decoder_for_get_copy_data_set(VALUE self, VALUE typemap)
+pgconn_decoder_for_get_copy_data_set(VALUE self, VALUE decoder)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
-	if( typemap != Qnil ){
-		if ( !rb_obj_is_kind_of(typemap, rb_cPG_Coder) ) {
-			rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::Coder)",
-					rb_obj_classname( typemap ) );
-		}
-		Check_Type(typemap, T_DATA);
+	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 = typemap;
+	this->decoder_for_get_copy_data = decoder;
 
-	return typemap;
+	return decoder;
 }
 
 /*
@@ -4141,6 +4214,7 @@ void
 init_pg_connection()
 {
 	s_id_encode = rb_intern("encode");
+	s_id_autoclose_set = rb_intern("autoclose=");
 	sym_type = ID2SYM(rb_intern("type"));
 	sym_format = ID2SYM(rb_intern("format"));
 	sym_value = ID2SYM(rb_intern("value"));
@@ -4156,10 +4230,6 @@ init_pg_connection()
 	/******     PG::Connection CLASS METHODS     ******/
 	rb_define_alloc_func( rb_cPGconn, pgconn_s_allocate );
 
-	SINGLETON_ALIAS(rb_cPGconn, "connect", "new");
-	SINGLETON_ALIAS(rb_cPGconn, "open", "new");
-	SINGLETON_ALIAS(rb_cPGconn, "setdb", "new");
-	SINGLETON_ALIAS(rb_cPGconn, "setdblogin", "new");
 	rb_define_singleton_method(rb_cPGconn, "escape_string", pgconn_s_escape, 1);
 	SINGLETON_ALIAS(rb_cPGconn, "escape", "escape_string");
 	rb_define_singleton_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
@@ -4168,14 +4238,14 @@ 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, "ping", pgconn_s_ping, -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);
 
 	/******     PG::Connection INSTANCE METHODS: Connection Control     ******/
-	rb_define_method(rb_cPGconn, "initialize", pgconn_init, -1);
 	rb_define_method(rb_cPGconn, "connect_poll", pgconn_connect_poll, 0);
 	rb_define_method(rb_cPGconn, "finish", pgconn_finish, 0);
 	rb_define_method(rb_cPGconn, "finished?", pgconn_finished_p, 0);
-	rb_define_method(rb_cPGconn, "reset", pgconn_reset, 0);
+	rb_define_method(rb_cPGconn, "sync_reset", pgconn_sync_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_alias(rb_cPGconn, "close", "finish");
@@ -4187,9 +4257,7 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "host", pgconn_host, 0);
 	rb_define_method(rb_cPGconn, "port", pgconn_port, 0);
 	rb_define_method(rb_cPGconn, "tty", pgconn_tty, 0);
-#ifdef HAVE_PQCONNINFO
 	rb_define_method(rb_cPGconn, "conninfo", pgconn_conninfo, 0);
-#endif
 	rb_define_method(rb_cPGconn, "options", pgconn_options, 0);
 	rb_define_method(rb_cPGconn, "status", pgconn_status, 0);
 	rb_define_method(rb_cPGconn, "transaction_status", pgconn_transaction_status, 0);
@@ -4200,17 +4268,18 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "socket", pgconn_socket, 0);
 	rb_define_method(rb_cPGconn, "socket_io", pgconn_socket_io, 0);
 	rb_define_method(rb_cPGconn, "backend_pid", pgconn_backend_pid, 0);
+	rb_define_method(rb_cPGconn, "backend_key", pgconn_backend_key, 0);
 	rb_define_method(rb_cPGconn, "connection_needs_password", pgconn_connection_needs_password, 0);
 	rb_define_method(rb_cPGconn, "connection_used_password", pgconn_connection_used_password, 0);
 	/* rb_define_method(rb_cPGconn, "getssl", pgconn_getssl, 0); */
 
 	/******     PG::Connection INSTANCE METHODS: Command Execution     ******/
-	rb_define_method(rb_cPGconn, "sync_exec", pgconn_exec, -1);
-	rb_define_method(rb_cPGconn, "sync_exec_params", pgconn_exec_params, -1);
-	rb_define_method(rb_cPGconn, "sync_prepare", pgconn_prepare, -1);
-	rb_define_method(rb_cPGconn, "sync_exec_prepared", pgconn_exec_prepared, -1);
-	rb_define_method(rb_cPGconn, "sync_describe_prepared", pgconn_describe_prepared, 1);
-	rb_define_method(rb_cPGconn, "sync_describe_portal", pgconn_describe_portal, 1);
+	rb_define_method(rb_cPGconn, "sync_exec", pgconn_sync_exec, -1);
+	rb_define_method(rb_cPGconn, "sync_exec_params", pgconn_sync_exec_params, -1);
+	rb_define_method(rb_cPGconn, "sync_prepare", pgconn_sync_prepare, -1);
+	rb_define_method(rb_cPGconn, "sync_exec_prepared", pgconn_sync_exec_prepared, -1);
+	rb_define_method(rb_cPGconn, "sync_describe_prepared", pgconn_sync_describe_prepared, 1);
+	rb_define_method(rb_cPGconn, "sync_describe_portal", pgconn_sync_describe_portal, 1);
 
 	rb_define_method(rb_cPGconn, "exec", pgconn_async_exec, -1);
 	rb_define_method(rb_cPGconn, "exec_params", pgconn_async_exec_params, -1);
@@ -4243,25 +4312,26 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "send_query_prepared", pgconn_send_query_prepared, -1);
 	rb_define_method(rb_cPGconn, "send_describe_prepared", pgconn_send_describe_prepared, 1);
 	rb_define_method(rb_cPGconn, "send_describe_portal", pgconn_send_describe_portal, 1);
-	rb_define_method(rb_cPGconn, "get_result", pgconn_get_result, 0);
+	rb_define_method(rb_cPGconn, "sync_get_result", pgconn_sync_get_result, 0);
 	rb_define_method(rb_cPGconn, "consume_input", pgconn_consume_input, 0);
 	rb_define_method(rb_cPGconn, "is_busy", pgconn_is_busy, 0);
-	rb_define_method(rb_cPGconn, "setnonblocking", pgconn_setnonblocking, 1);
-	rb_define_method(rb_cPGconn, "isnonblocking", pgconn_isnonblocking, 0);
-	rb_define_alias(rb_cPGconn, "nonblocking?", "isnonblocking");
-	rb_define_method(rb_cPGconn, "flush", pgconn_flush, 0);
+	rb_define_method(rb_cPGconn, "sync_setnonblocking", pgconn_sync_setnonblocking, 1);
+	rb_define_method(rb_cPGconn, "sync_isnonblocking", pgconn_sync_isnonblocking, 0);
+	rb_define_method(rb_cPGconn, "sync_flush", pgconn_sync_flush, 0);
+	rb_define_method(rb_cPGconn, "flush", pgconn_async_flush, 0);
+	rb_define_alias(rb_cPGconn, "async_flush", "flush");
 	rb_define_method(rb_cPGconn, "discard_results", pgconn_discard_results, 0);
 
 	/******     PG::Connection INSTANCE METHODS: Cancelling Queries in Progress     ******/
-	rb_define_method(rb_cPGconn, "cancel", pgconn_cancel, 0);
+	rb_define_method(rb_cPGconn, "sync_cancel", pgconn_sync_cancel, 0);
 
 	/******     PG::Connection INSTANCE METHODS: NOTIFY     ******/
 	rb_define_method(rb_cPGconn, "notifies", pgconn_notifies, 0);
 
 	/******     PG::Connection INSTANCE METHODS: COPY     ******/
-	rb_define_method(rb_cPGconn, "put_copy_data", pgconn_put_copy_data, -1);
-	rb_define_method(rb_cPGconn, "put_copy_end", pgconn_put_copy_end, -1);
-	rb_define_method(rb_cPGconn, "get_copy_data", pgconn_get_copy_data, -1);
+	rb_define_method(rb_cPGconn, "sync_put_copy_data", pgconn_sync_put_copy_data, -1);
+	rb_define_method(rb_cPGconn, "sync_put_copy_end", pgconn_sync_put_copy_end, -1);
+	rb_define_method(rb_cPGconn, "sync_get_copy_data", pgconn_sync_get_copy_data, -1);
 
 	/******     PG::Connection INSTANCE METHODS: Control Functions     ******/
 	rb_define_method(rb_cPGconn, "set_error_verbosity", pgconn_set_error_verbosity, 1);
@@ -4277,16 +4347,20 @@ init_pg_connection()
 
 	/******     PG::Connection INSTANCE METHODS: Other    ******/
 	rb_define_method(rb_cPGconn, "get_client_encoding", pgconn_get_client_encoding, 0);
-	rb_define_method(rb_cPGconn, "set_client_encoding", pgconn_set_client_encoding, 1);
+	rb_define_method(rb_cPGconn, "sync_set_client_encoding", pgconn_sync_set_client_encoding, 1);
+	rb_define_method(rb_cPGconn, "set_client_encoding", pgconn_async_set_client_encoding, 1);
+	rb_define_alias(rb_cPGconn, "async_set_client_encoding", "set_client_encoding");
 	rb_define_alias(rb_cPGconn, "client_encoding=", "set_client_encoding");
-	rb_define_method(rb_cPGconn, "transaction", pgconn_transaction, 0);
 	rb_define_method(rb_cPGconn, "block", pgconn_block, -1);
+	rb_define_private_method(rb_cPGconn, "flush_data=", pgconn_flush_data_set, 1);
 	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);
-	rb_define_method(rb_cPGconn, "get_last_result", pgconn_get_last_result, 0);
+	rb_define_method(rb_cPGconn, "sync_get_last_result", pgconn_sync_get_last_result, 0);
+	rb_define_method(rb_cPGconn, "get_last_result", pgconn_async_get_last_result, 0);
+	rb_define_alias(rb_cPGconn, "async_get_last_result", "get_last_result");
 #ifdef HAVE_PQENCRYPTPASSWORDCONN
-	rb_define_method(rb_cPGconn, "encrypt_password", pgconn_encrypt_password, -1);
+	rb_define_method(rb_cPGconn, "sync_encrypt_password", pgconn_sync_encrypt_password, -1);
 #endif
 
 #ifdef HAVE_PQSSLATTRIBUTE
@@ -4295,6 +4369,14 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "ssl_attribute_names", pgconn_ssl_attribute_names, 0);
 #endif
 
+#ifdef HAVE_PQENTERPIPELINEMODE
+	rb_define_method(rb_cPGconn, "pipeline_status", pgconn_pipeline_status, 0);
+	rb_define_method(rb_cPGconn, "enter_pipeline_mode", pgconn_enter_pipeline_mode, 0);
+	rb_define_method(rb_cPGconn, "exit_pipeline_mode", pgconn_exit_pipeline_mode, 0);
+	rb_define_method(rb_cPGconn, "pipeline_sync", pgconn_pipeline_sync, 0);
+	rb_define_method(rb_cPGconn, "send_flush_request", pgconn_send_flush_request, 0);
+#endif
+
 	/******     PG::Connection INSTANCE METHODS: Large Object Support     ******/
 	rb_define_method(rb_cPGconn, "lo_creat", pgconn_locreat, -1);
 	rb_define_alias(rb_cPGconn, "locreat", "lo_creat");