pg 0.21.0 → 1.1.4

data/ext/pg_binary_decoder.c

@@ -1,9 +1,10 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_binary_decoder.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
+ * $Id$
  *
  */
 
+#include "ruby/version.h"
 #include "pg.h"
 #include "util.h"
 #ifdef HAVE_INTTYPES_H
@@ -21,7 +22,7 @@ VALUE rb_mPG_BinaryDecoder;
  *
  */
 static VALUE
-pg_bin_dec_boolean(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_boolean(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	if (len < 1) {
 		rb_raise( rb_eTypeError, "wrong data for binary boolean converter in tuple %d field %d", tuple, field);
@@ -37,7 +38,7 @@ pg_bin_dec_boolean(t_pg_coder *conv, char *val, int len, int tuple, int field, i
  *
  */
 static VALUE
-pg_bin_dec_integer(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_integer(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	switch( len ){
 		case 2:
@@ -59,7 +60,7 @@ pg_bin_dec_integer(t_pg_coder *conv, char *val, int len, int tuple, int field, i
  *
  */
 static VALUE
-pg_bin_dec_float(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_float(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	union {
 		float f;
@@ -91,7 +92,7 @@ pg_bin_dec_float(t_pg_coder *conv, char *val, int len, int tuple, int field, int
  *
  */
 VALUE
-pg_bin_dec_bytea(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_bytea(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	VALUE ret;
 	ret = rb_tainted_str_new( val, len );
@@ -106,7 +107,7 @@ pg_bin_dec_bytea(t_pg_coder *conv, char *val, int len, int tuple, int field, int
  *
  */
 static VALUE
-pg_bin_dec_to_base64(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_to_base64(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
 	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, this->comp.format);
@@ -130,6 +131,70 @@ pg_bin_dec_to_base64(t_pg_coder *conv, char *val, int len, int tuple, int field,
 	return out_value;
 }
 
+#define PG_INT64_MIN	(-0x7FFFFFFFFFFFFFFFL - 1)
+#define PG_INT64_MAX	0x7FFFFFFFFFFFFFFFL
+
+/*
+ * Document-class: PG::BinaryDecoder::Timestamp < PG::SimpleDecoder
+ *
+ * This is a decoder class for conversion of PostgreSQL binary timestamps
+ * to Ruby Time objects.
+ *
+ * The following flags can be used to specify timezone interpretation:
+ * * +PG::Coder::TIMESTAMP_DB_UTC+ : Interpret timestamp as UTC time (default)
+ * * +PG::Coder::TIMESTAMP_DB_LOCAL+ : Interpret timestamp as local time
+ * * +PG::Coder::TIMESTAMP_APP_UTC+ : Return timestamp as UTC time (default)
+ * * +PG::Coder::TIMESTAMP_APP_LOCAL+ : Return timestamp as local time
+ *
+ * Example:
+ *   deco = PG::BinaryDecoder::Timestamp.new(flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_LOCAL)
+ *   deco.decode("\0"*8)  # => 2000-01-01 01:00:00 +0100
+ */
+static VALUE
+pg_bin_dec_timestamp(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
+{
+	int64_t timestamp;
+	int64_t sec;
+	int64_t nsec;
+	VALUE t;
+
+	if( len != sizeof(timestamp) ){
+		rb_raise( rb_eTypeError, "wrong data for timestamp converter in tuple %d field %d length %d", tuple, field, len);
+	}
+
+	timestamp = read_nbo64(val);
+
+	switch(timestamp){
+		case PG_INT64_MAX:
+			return rb_str_new2("infinity");
+		case PG_INT64_MIN:
+			return rb_str_new2("-infinity");
+		default:
+			/* PostgreSQL's timestamp is based on year 2000 and Ruby's time is based on 1970.
+			 * Adjust the 30 years difference. */
+			sec = (timestamp / 1000000) + 10957L * 24L * 3600L;
+			nsec = (timestamp % 1000000) * 1000;
+
+#if (RUBY_API_VERSION_MAJOR > 2 || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 3)) && defined(NEGATIVE_TIME_T) && defined(SIZEOF_TIME_T) && SIZEOF_TIME_T >= 8
+			/* Fast path for time conversion */
+			{
+				struct timespec ts = {sec, nsec};
+				t = rb_time_timespec_new(&ts, conv->flags & PG_CODER_TIMESTAMP_APP_LOCAL ? INT_MAX : INT_MAX-1);
+			}
+#else
+			t = rb_funcall(rb_cTime, rb_intern("at"), 2, LL2NUM(sec), LL2NUM(nsec / 1000));
+			if( !(conv->flags & PG_CODER_TIMESTAMP_APP_LOCAL) ) {
+				t = rb_funcall(t, rb_intern("utc"), 0);
+			}
+#endif
+			if( conv->flags & PG_CODER_TIMESTAMP_DB_LOCAL ) {
+				/* interpret it as local time */
+				t = rb_funcall(t, rb_intern("-"), 1, rb_funcall(t, rb_intern("utc_offset"), 0));
+			}
+			return t;
+	}
+}
+
 /*
  * Document-class: PG::BinaryDecoder::String < PG::SimpleDecoder
  *
@@ -156,6 +221,8 @@ init_pg_binary_decoder()
 	pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_BinaryDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Bytea", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Bytea", pg_bin_dec_bytea, rb_cPG_SimpleDecoder, rb_mPG_BinaryDecoder );
+	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Timestamp", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Timestamp", pg_bin_dec_timestamp, rb_cPG_SimpleDecoder, rb_mPG_BinaryDecoder );
 
 	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "ToBase64", rb_cPG_CompositeDecoder ); */
 	pg_define_coder( "ToBase64", pg_bin_dec_to_base64, rb_cPG_CompositeDecoder, rb_mPG_BinaryDecoder );

data/ext/pg_coder.c

@@ -38,6 +38,7 @@ pg_coder_init_encoder( VALUE self )
 	this->coder_obj = self;
 	this->oid = 0;
 	this->format = 0;
+	this->flags = 0;
 	rb_iv_set( self, "@name", Qnil );
 }
 
@@ -56,6 +57,7 @@ pg_coder_init_decoder( VALUE self )
 	this->coder_obj = self;
 	this->oid = 0;
 	this->format = 0;
+	this->flags = 0;
 	rb_iv_set( self, "@name", Qnil );
 }
 
@@ -192,7 +194,11 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 	if( NIL_P(argv[0]) )
 		return Qnil;
 
-	val = StringValuePtr(argv[0]);
+	if( this->format == 0 ){
+		val = StringValueCStr(argv[0]);
+	}else{
+		val = StringValuePtr(argv[0]);
+	}
 	if( !this->dec_func ){
 		rb_raise(rb_eRuntimeError, "no decoder function defined");
 	}
@@ -265,6 +271,36 @@ pg_coder_format_get(VALUE self)
 	return INT2NUM(this->format);
 }
 
+/*
+ * call-seq:
+ *    coder.flags = Integer
+ *
+ * Set coder specific bitwise OR-ed flags.
+ * See the particular en- or decoder description for available flags.
+ *
+ * The default is +0+.
+ */
+static VALUE
+pg_coder_flags_set(VALUE self, VALUE flags)
+{
+	t_pg_coder *this = DATA_PTR(self);
+	this->flags = NUM2INT(flags);
+	return flags;
+}
+
+/*
+ * call-seq:
+ *    coder.flags -> Integer
+ *
+ * Get current bitwise OR-ed coder flags.
+ */
+static VALUE
+pg_coder_flags_get(VALUE self)
+{
+	t_pg_coder *this = DATA_PTR(self);
+	return INT2NUM(this->flags);
+}
+
 /*
  * call-seq:
  *    coder.needs_quotation = Boolean
@@ -403,14 +439,14 @@ pg_coder_enc_func(t_pg_coder *this)
 }
 
 static VALUE
-pg_text_dec_in_ruby(t_pg_coder *this, char *val, int len, int tuple, int field, int enc_idx)
+pg_text_dec_in_ruby(t_pg_coder *this, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	VALUE string = pg_text_dec_string(this, val, len, tuple, field, enc_idx);
 	return rb_funcall( this->coder_obj, s_id_decode, 3, string, INT2NUM(tuple), INT2NUM(field) );
 }
 
 static VALUE
-pg_bin_dec_in_ruby(t_pg_coder *this, char *val, int len, int tuple, int field, int enc_idx)
+pg_bin_dec_in_ruby(t_pg_coder *this, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	VALUE string = pg_bin_dec_bytea(this, val, len, tuple, field, enc_idx);
 	return rb_funcall( this->coder_obj, s_id_decode, 3, string, INT2NUM(tuple), INT2NUM(field) );
@@ -457,6 +493,19 @@ init_pg_coder()
 	rb_define_method( rb_cPG_Coder, "oid", pg_coder_oid_get, 0 );
 	rb_define_method( rb_cPG_Coder, "format=", pg_coder_format_set, 1 );
 	rb_define_method( rb_cPG_Coder, "format", pg_coder_format_get, 0 );
+	rb_define_method( rb_cPG_Coder, "flags=", pg_coder_flags_set, 1 );
+	rb_define_method( rb_cPG_Coder, "flags", pg_coder_flags_get, 0 );
+
+	/* define flags to be used with PG::Coder#flags= */
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_DB_UTC", INT2NUM(PG_CODER_TIMESTAMP_DB_UTC));
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_DB_LOCAL", INT2NUM(PG_CODER_TIMESTAMP_DB_LOCAL));
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_APP_UTC", INT2NUM(PG_CODER_TIMESTAMP_APP_UTC));
+	rb_define_const( rb_cPG_Coder, "TIMESTAMP_APP_LOCAL", INT2NUM(PG_CODER_TIMESTAMP_APP_LOCAL));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_MASK", INT2NUM(PG_CODER_FORMAT_ERROR_MASK));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_TO_RAISE", INT2NUM(PG_CODER_FORMAT_ERROR_TO_RAISE));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_TO_STRING", INT2NUM(PG_CODER_FORMAT_ERROR_TO_STRING));
+	rb_define_const( rb_cPG_Coder, "FORMAT_ERROR_TO_PARTIAL", INT2NUM(PG_CODER_FORMAT_ERROR_TO_PARTIAL));
+
 	/*
 	 * Name of the coder or the corresponding data type.
 	 *

data/ext/pg_connection.c

@@ -1,6 +1,6 @@
 /*
  * pg_connection.c - PG::Connection class extension
- * $Id: pg_connection.c,v 2e17f315848e 2017/01/14 20:05:06 lars $
+ * $Id$
  *
  */
 
@@ -18,19 +18,8 @@ static PQnoticeReceiver default_notice_receiver = NULL;
 static PQnoticeProcessor default_notice_processor = NULL;
 
 static VALUE pgconn_finish( VALUE );
-#ifdef M17N_SUPPORTED
 static VALUE pgconn_set_default_encoding( VALUE self );
 void pgconn_set_internal_encoding_index( VALUE );
-#endif
-
-#ifndef HAVE_RB_THREAD_FD_SELECT
-#define rb_fdset_t fd_set
-#define rb_fd_init(f)
-#define rb_fd_zero(f)  FD_ZERO(f)
-#define rb_fd_set(n, f)  FD_SET(n, f)
-#define rb_fd_term(f)
-#define rb_thread_fd_select rb_thread_select
-#endif
 
 /*
  * Global functions
@@ -95,9 +84,8 @@ pgconn_close_socket_io( VALUE self )
 	VALUE socket_io = this->socket_io;
 
 	if ( RTEST(socket_io) ) {
-#if defined(_WIN32) && defined(HAVE_RB_W32_WRAP_IO_HANDLE)
-		int ruby_sd = NUM2INT(rb_funcall( socket_io, rb_intern("fileno"), 0 ));
-		if( rb_w32_unwrap_io_handle(ruby_sd) ){
+#if defined(_WIN32)
+		if( rb_w32_unwrap_io_handle(this->ruby_sd) ){
 			rb_raise(rb_eConnectionBad, "Could not unwrap win32 socket handle");
 		}
 #endif
@@ -176,6 +164,10 @@ pgconn_gc_mark( t_pg_connection *this )
 static void
 pgconn_gc_free( t_pg_connection *this )
 {
+#if defined(_WIN32)
+	if ( RTEST(this->socket_io) )
+		rb_w32_unwrap_io_handle( this->ruby_sd );
+#endif
 	if (this->pgconn != NULL)
 		PQfinish( this->pgconn );
 
@@ -209,6 +201,7 @@ pgconn_s_allocate( VALUE klass )
 	this->decoder_for_get_copy_data = Qnil;
 	this->trace_stream = Qnil;
 	this->external_encoding = Qnil;
+	this->guess_result_memsize = 1;
 
 	return self;
 }
@@ -291,9 +284,7 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 		rb_exc_raise(error);
 	}
 
-#ifdef M17N_SUPPORTED
 	pgconn_set_default_encoding( self );
-#endif
 
 	if (rb_block_given_p()) {
 		return rb_ensure(rb_yield, self, pgconn_finish, self);
@@ -349,7 +340,6 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	return rb_conn;
 }
 
-#ifdef HAVE_PQPING
 /*
  * call-seq:
  *    PG::Connection.ping(connection_hash)       -> Integer
@@ -367,6 +357,8 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
  *   could not establish connection
  * [+PQPING_NO_ATTEMPT+]
  *   connection not attempted (bad params)
+ *
+ * Available since PostgreSQL-9.1
  */
 static VALUE
 pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
@@ -379,7 +371,6 @@ pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
 
 	return INT2FIX((int)ping);
 }
-#endif
 
 
 /*
@@ -418,16 +409,65 @@ pgconn_s_conndefaults(VALUE self)
 }
 
 
+#ifdef HAVE_PQENCRYPTPASSWORDCONN
 /*
  * call-seq:
- *    PG::Connection.encrypt_password( password, username ) -> String
+ *    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.
  *
- * This function is intended to be used by client applications that
- * send commands like: +ALTER USER joe PASSWORD 'pwd'+.
- * The arguments are the cleartext password, and the SQL name
- * of the user it is for.
+ * 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
+ */
+static VALUE
+pgconn_encrypt_password(int argc, VALUE *argv, VALUE self)
+{
+	char *encrypted = NULL;
+	VALUE rval = Qnil;
+	VALUE password, username, algorithm;
+	PGconn *conn = pg_get_pgconn(self);
+
+	rb_scan_args( argc, argv, "21", &password, &username, &algorithm );
+
+	Check_Type(password, T_STRING);
+	Check_Type(username, T_STRING);
+
+	encrypted = gvl_PQencryptPasswordConn(conn, StringValueCStr(password), StringValueCStr(username), RTEST(algorithm) ? StringValueCStr(algorithm) : NULL);
+	if ( encrypted ) {
+		rval = rb_str_new2( encrypted );
+		PQfreemem( encrypted );
+
+		OBJ_INFECT( rval, password );
+		OBJ_INFECT( rval, username );
+		OBJ_INFECT( rval, algorithm );
+	} else {
+		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
+	}
+
+	return rval;
+}
+#endif
+
+
+/*
+ * call-seq:
+ *    PG::Connection.encrypt_password( password, username ) -> String
+ *
+ * This is an older, deprecated version of #encrypt_password.
+ * The difference is that this function always uses +md5+ as the encryption algorithm.
+ *
  */
 static VALUE
 pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
@@ -613,7 +653,7 @@ pgconn_user(VALUE self)
  * call-seq:
  *    conn.pass()
  *
- * Returns the authenticated user name.
+ * Returns the authenticated password.
  */
 static VALUE
 pgconn_pass(VALUE self)
@@ -686,6 +726,7 @@ pgconn_options(VALUE self)
  *
  * Returns the connection options used by a live connection.
  *
+ * Available since PostgreSQL-9.3
  */
 static VALUE
 pgconn_conninfo( VALUE self )
@@ -807,6 +848,8 @@ pgconn_error_message(VALUE self)
  * call-seq:
  *    conn.socket() -> Integer
  *
+ * This method is deprecated. Please use the more portable method #socket_io .
+ *
  * Returns the socket's file descriptor for this connection.
  * <tt>IO.for_fd()</tt> can be used to build a proper IO object to the socket.
  * If you do so, you will likely also want to set <tt>autoclose=false</tt>
@@ -815,7 +858,7 @@ pgconn_error_message(VALUE self)
  * creates an IO that's associated with the connection object itself,
  * and so won't go out of scope until the connection does.
  *
- * *Note:* On Windows the file descriptor is not really usable,
+ * *Note:* On Windows the file descriptor is not usable,
  * since it can not be used to build a Ruby IO object.
  */
 static VALUE
@@ -827,22 +870,17 @@ pgconn_socket(VALUE self)
 	return INT2NUM(sd);
 }
 
-
-#if !defined(_WIN32) || defined(HAVE_RB_W32_WRAP_IO_HANDLE)
-
 /*
  * call-seq:
  *    conn.socket_io() -> IO
  *
- * Fetch a memoized IO object created from the Connection's underlying socket.
+ * 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.
  *
  * 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.
- *
- * This method can also be used on Windows but requires Ruby-2.0+.
+ * goes out of scope. In contrast to #socket, it also works on Windows.
  */
 static VALUE
 pgconn_socket_io(VALUE self)
@@ -859,16 +897,15 @@ pgconn_socket_io(VALUE self)
 
 		#ifdef _WIN32
 			ruby_sd = rb_w32_wrap_io_handle((HANDLE)(intptr_t)sd, O_RDWR|O_BINARY|O_NOINHERIT);
+			this->ruby_sd = ruby_sd;
 		#else
 			ruby_sd = sd;
 		#endif
 
 		socket_io = rb_funcall( rb_cIO, rb_intern("for_fd"), 1, INT2NUM(ruby_sd) );
 
-		/* Disable autoclose feature, when supported */
-		if( rb_respond_to(socket_io, id_autoclose) ){
-			rb_funcall( socket_io, id_autoclose, 1, Qfalse );
-		}
+		/* Disable autoclose feature */
+		rb_funcall( socket_io, id_autoclose, 1, Qfalse );
 
 		this->socket_io = socket_io;
 	}
@@ -876,8 +913,6 @@ pgconn_socket_io(VALUE self)
 	return socket_io;
 }
 
-#endif
-
 /*
  * call-seq:
  *    conn.backend_pid() -> Integer
@@ -930,7 +965,7 @@ static VALUE pgconn_exec_params( int, VALUE *, VALUE );
  *    conn.exec(sql) {|pg_result| block }
  *
  * Sends SQL query request specified by _sql_ to PostgreSQL.
- * Returns a PG::Result instance on success.
+ * On success, it returns a PG::Result instance with all result rows and columns.
  * On failure, it raises a PG::Error.
  *
  * For backward compatibility, if you pass more than one parameter to this method,
@@ -941,9 +976,9 @@ static VALUE pgconn_exec_params( int, VALUE *, VALUE );
  * and the PG::Result object will  automatically be cleared when the block terminates.
  * In this instance, <code>conn.exec</code> returns the value of the block.
  *
- * #exec is implemented on the synchronous command processing API of libpq, whereas
+ * #sync_exec is implemented on the synchronous command processing API of libpq, whereas
  * #async_exec is implemented on the asynchronous API.
- * #exec is somewhat faster that #async_exec, but blocks any signals to be processed until
+ * #sync_exec is somewhat faster that #async_exec, but blocks any signals to be processed until
  * the query is finished. This is most notably visible by a delayed reaction to Control+C.
  * Both methods ensure that other threads can process while waiting for the server to
  * complete the request.
@@ -955,8 +990,8 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 	PGresult *result = NULL;
 	VALUE rb_pgresult;
 
-	/* If called with no parameters, use PQexec */
-	if ( argc == 1 ) {
+	/* If called with no or nil parameters, use PQexec for compatibility */
+	if ( argc == 1 || (argc >= 2 && argc <= 4 && NIL_P(argv[1]) )) {
 		VALUE query_str = argv[0];
 
 		result = gvl_PQexec(conn, pg_cstr_enc(query_str, ENCODING_GET(self)));
@@ -967,11 +1002,10 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 		}
 		return rb_pgresult;
 	}
+	pg_deprecated(0, ("forwarding exec to exec_params is deprecated"));
 
 	/* Otherwise, just call #exec_params instead for backward-compatibility */
-	else {
-		return pgconn_exec_params( argc, argv, self );
-	}
+	return pgconn_exec_params( argc, argv, self );
 
 }
 
@@ -1254,7 +1288,7 @@ pgconn_query_assign_typemap( VALUE self, struct query_params_data *paramsData )
  * for binary.
  *
  * type_map can be a PG::TypeMap derivation (such as PG::BasicTypeMapForQueries).
- * This will type cast the params form various Ruby types before transmission
+ * This will type cast the params from various Ruby types before transmission
  * based on the encoders defined by the type map. When a type encoder is used
  * the format and oid of a given bind parameter are retrieved from the encoder
  * instead out of the hash form described above.
@@ -1274,14 +1308,16 @@ pgconn_exec_params( int argc, VALUE *argv, VALUE self )
 	int resultFormat;
 	struct query_params_data paramsData = { ENCODING_GET(self) };
 
+	/* For compatibility we accept 1 to 4 parameters */
 	rb_scan_args(argc, argv, "13", &command, &paramsData.params, &in_res_fmt, &paramsData.typemap);
 	paramsData.with_types = 1;
 
 	/*
-	 * Handle the edge-case where the caller is coming from #exec, but passed an explict +nil+
-	 * for the second parameter.
+	 * For backward compatibility no or +nil+ for the second parameter
+	 * is passed to #exec
 	 */
 	if ( NIL_P(paramsData.params) ) {
+		pg_deprecated(1, ("forwarding exec_params to exec is deprecated"));
 		return pgconn_exec( 1, argv, self );
 	}
 	pgconn_query_assign_typemap( self, &paramsData );
@@ -1390,7 +1426,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  * for binary.
  *
  * type_map can be a PG::TypeMap derivation (such as PG::BasicTypeMapForQueries).
- * This will type cast the params form various Ruby types before transmission
+ * This will type cast the params from various Ruby types before transmission
  * based on the encoders defined by the type map. When a type encoder is used
  * the format and oid of a given bind parameter are retrieved from the encoder
  * instead out of the hash form described above.
@@ -1547,7 +1583,7 @@ pgconn_s_escape(VALUE self, VALUE string)
 	int enc_idx;
 	int singleton = !rb_obj_is_kind_of(self, rb_cPGconn);
 
-	Check_Type(string, T_STRING);
+	StringValueCStr(string);
 	enc_idx = ENCODING_GET( singleton ? string : self );
 	if( ENCODING_GET(string) != enc_idx ){
 		string = rb_str_export_to_enc(string, rb_enc_from_index(enc_idx));
@@ -1646,12 +1682,13 @@ pgconn_s_unescape_bytea(VALUE self, VALUE str)
 	return ret;
 }
 
-#ifdef HAVE_PQESCAPELITERAL
 /*
  * call-seq:
  *    conn.escape_literal( str ) -> String
  *
  * Escape an arbitrary String +str+ as a literal.
+ *
+ * Available since PostgreSQL-9.0
  */
 static VALUE
 pgconn_escape_literal(VALUE self, VALUE string)
@@ -1662,7 +1699,7 @@ pgconn_escape_literal(VALUE self, VALUE string)
 	VALUE result = Qnil;
 	int enc_idx = ENCODING_GET(self);
 
-	Check_Type(string, T_STRING);
+	StringValueCStr(string);
 	if( ENCODING_GET(string) != enc_idx ){
 		string = rb_str_export_to_enc(string, rb_enc_from_index(enc_idx));
 	}
@@ -1682,9 +1719,7 @@ pgconn_escape_literal(VALUE self, VALUE string)
 
 	return result;
 }
-#endif
 
-#ifdef HAVE_PQESCAPEIDENTIFIER
 /*
  * call-seq:
  *    conn.escape_identifier( str ) -> String
@@ -1694,6 +1729,8 @@ pgconn_escape_literal(VALUE self, VALUE string)
  * This method does the same as #quote_ident with a String argument,
  * but it doesn't support an Array argument and it makes use of libpq
  * to process the string.
+ *
+ * Available since PostgreSQL-9.0
  */
 static VALUE
 pgconn_escape_identifier(VALUE self, VALUE string)
@@ -1704,7 +1741,7 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 	VALUE result = Qnil;
 	int enc_idx = ENCODING_GET(self);
 
-	Check_Type(string, T_STRING);
+	StringValueCStr(string);
 	if( ENCODING_GET(string) != enc_idx ){
 		string = rb_str_export_to_enc(string, rb_enc_from_index(enc_idx));
 	}
@@ -1724,9 +1761,7 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 
 	return result;
 }
-#endif
 
-#ifdef HAVE_PQSETSINGLEROWMODE
 /*
  * call-seq:
  *    conn.set_single_row_mode -> self
@@ -1763,6 +1798,7 @@ pgconn_escape_identifier(VALUE self, VALUE string)
  *     end
  *   end
  *
+ * Available since PostgreSQL-9.2
  */
 static VALUE
 pgconn_set_single_row_mode(VALUE self)
@@ -1779,17 +1815,55 @@ pgconn_set_single_row_mode(VALUE self)
 
 	return self;
 }
-#endif
+
+static VALUE pgconn_send_query_params(int argc, VALUE *argv, VALUE self);
 
 /*
  * call-seq:
- *    conn.send_query(sql [, params, result_format[, type_map ]] ) -> nil
+ *    conn.send_query(sql) -> nil
  *
  * Sends SQL query request specified by _sql_ to PostgreSQL for
  * asynchronous processing, and immediately returns.
  * On failure, it raises a PG::Error.
  *
- * +params+ is an optional array of the bind parameters for the SQL query.
+ * For backward compatibility, if you pass more than one parameter to this method,
+ * it will call #send_query_params for you. New code should explicitly use #send_query_params if
+ * argument placeholders are used.
+ *
+ */
+static VALUE
+pgconn_send_query(int argc, VALUE *argv, VALUE self)
+{
+	PGconn *conn = pg_get_pgconn(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(conn, pg_cstr_enc(argv[0], ENCODING_GET(self))) == 0) {
+			error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
+			rb_iv_set(error, "@connection", self);
+			rb_exc_raise(error);
+		}
+		return Qnil;
+	}
+
+	pg_deprecated(2, ("forwarding async_exec to async_exec_params and send_query to send_query_params is deprecated"));
+
+	/* If called with parameters, and optionally result_format,
+	 * use PQsendQueryParams
+	 */
+	return pgconn_send_query_params( argc, argv, self);
+}
+
+/*
+ * call-seq:
+ *    conn.send_query_params(sql, params [, result_format [, type_map ]] ) -> nil
+ *
+ * Sends SQL query request specified by _sql_ to PostgreSQL for
+ * asynchronous processing, and immediately returns.
+ * On failure, it raises a PG::Error.
+ *
+ * +params+ is an array of the bind parameters for the SQL query.
  * Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
@@ -1813,14 +1887,14 @@ pgconn_set_single_row_mode(VALUE self)
  * for binary.
  *
  * type_map can be a PG::TypeMap derivation (such as PG::BasicTypeMapForQueries).
- * This will type cast the params form various Ruby types before transmission
+ * This will type cast the params from various Ruby types before transmission
  * based on the encoders defined by the type map. When a type encoder is used
  * the format and oid of a given bind parameter are retrieved from the encoder
  * instead out of the hash form described above.
  *
  */
 static VALUE
-pgconn_send_query(int argc, VALUE *argv, VALUE self)
+pgconn_send_query_params(int argc, VALUE *argv, VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int result;
@@ -1830,23 +1904,9 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 	int resultFormat;
 	struct query_params_data paramsData = { ENCODING_GET(self) };
 
-	rb_scan_args(argc, argv, "13", &command, &paramsData.params, &in_res_fmt, &paramsData.typemap);
+	rb_scan_args(argc, argv, "22", &command, &paramsData.params, &in_res_fmt, &paramsData.typemap);
 	paramsData.with_types = 1;
 
-	/* If called with no parameters, use PQsendQuery */
-	if(NIL_P(paramsData.params)) {
-		if(gvl_PQsendQuery(conn, pg_cstr_enc(command, paramsData.enc_idx)) == 0) {
-			error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
-			rb_iv_set(error, "@connection", self);
-			rb_exc_raise(error);
-		}
-		return Qnil;
-	}
-
-	/* If called with parameters, and optionally result_format,
-	 * use PQsendQueryParams
-	 */
-
 	pgconn_query_assign_typemap( self, &paramsData );
 	resultFormat = NIL_P(in_res_fmt) ? 0 : NUM2INT(in_res_fmt);
 	nParams = alloc_query_params( &paramsData );
@@ -1953,7 +2013,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
  * for binary.
  *
  * type_map can be a PG::TypeMap derivation (such as PG::BasicTypeMapForQueries).
- * This will type cast the params form various Ruby types before transmission
+ * This will type cast the params from various Ruby types before transmission
  * based on the encoders defined by the type map. When a type encoder is used
  * the format and oid of a given bind parameter are retrieved from the encoder
  * instead out of the hash form described above.
@@ -2203,7 +2263,6 @@ pgconn_flush(self)
 static VALUE
 pgconn_cancel(VALUE self)
 {
-#ifdef HAVE_PQGETCANCEL
 	char errbuf[256];
 	PGcancel *cancel;
 	VALUE retval;
@@ -2221,9 +2280,6 @@ pgconn_cancel(VALUE self)
 
 	PQfreeCancel(cancel);
 	return retval;
-#else
-	rb_notimplement();
-#endif
 }
 
 
@@ -2267,56 +2323,15 @@ pgconn_notifies(VALUE self)
 	return hash;
 }
 
-/* Win32 + Ruby 1.8 */
-#if !defined( HAVE_RUBY_VM_H ) && defined( _WIN32 )
-
-/*
- * Duplicate the sockets from libpq and create temporary CRT FDs
- */
-void create_crt_fd(fd_set *os_set, fd_set *crt_set)
-{
-	int i;
-	crt_set->fd_count = os_set->fd_count;
-	for (i = 0; i < os_set->fd_count; i++) {
-		WSAPROTOCOL_INFO wsa_pi;
-		/* dupicate the SOCKET */
-		int r = WSADuplicateSocket(os_set->fd_array[i], GetCurrentProcessId(), &wsa_pi);
-		SOCKET s = WSASocket(wsa_pi.iAddressFamily, wsa_pi.iSocketType, wsa_pi.iProtocol, &wsa_pi, 0, 0);
-		/* create the CRT fd so ruby can get back to the SOCKET */
-		int fd = _open_osfhandle(s, O_RDWR|O_BINARY);
-		os_set->fd_array[i] = s;
-		crt_set->fd_array[i] = fd;
-	}
-}
-
-/*
- * Clean up the CRT FDs from create_crt_fd()
- */
-void cleanup_crt_fd(fd_set *os_set, fd_set *crt_set)
-{
-	int i;
-	for (i = 0; i < os_set->fd_count; i++) {
-		/* cleanup the CRT fd */
-		_close(crt_set->fd_array[i]);
-		/* cleanup the duplicated SOCKET */
-		closesocket(os_set->fd_array[i]);
-	}
-}
-#endif
-
 /* Win32 + Ruby 1.9+ */
-#if defined( HAVE_RUBY_VM_H ) && defined( _WIN32 )
+#if defined( _WIN32 )
 /*
  * On Windows, use platform-specific strategies to wait for the socket
- * instead of rb_thread_select().
+ * instead of rb_wait_for_single_fd().
  */
 
 int rb_w32_wait_events( HANDLE *events, int num, DWORD timeout );
 
-/* If WIN32 and Ruby 1.9 do not use rb_thread_select() which sometimes hangs
- * and does not wait (nor sleep) any time even if timeout is given.
- * Instead use the Winsock events and rb_w32_wait_events(). */
-
 static void *
 wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readable)(PGconn *) )
 {
@@ -2393,7 +2408,7 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 
 #else
 
-/* non Win32 or Win32+Ruby-1.8 */
+/* non Win32 */
 
 static void *
 wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
@@ -2401,11 +2416,7 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 	int sd = PQsocket( conn );
 	int ret;
 	void *retval;
-	rb_fdset_t sd_rset;
 	struct timeval aborttime={0,0}, currtime, waittime;
-#ifdef _WIN32
-	rb_fdset_t crt_sd_rset;
-#endif
 
 	if ( sd < 0 )
 		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
@@ -2414,25 +2425,12 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 	if ( PQconsumeInput(conn) == 0 )
 		rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
 
-	rb_fd_init( &sd_rset );
-
 	if ( ptimeout ) {
 		gettimeofday(&currtime, NULL);
 		timeradd(&currtime, ptimeout, &aborttime);
 	}
 
 	while ( !(retval=is_readable(conn)) ) {
-		rb_fd_zero( &sd_rset );
-		rb_fd_set( sd, &sd_rset );
-
-#ifdef _WIN32
-		/* Ruby's FD_SET is modified on win32 to convert a file descriptor
-		 * to osfhandle, but we already get a osfhandle from PQsocket().
-		 * Therefore it's overwritten here. */
-		sd_rset.fd_array[0] = sd;
-		create_crt_fd(&sd_rset, &crt_sd_rset);
-#endif
-
 		if ( ptimeout ) {
 			gettimeofday(&currtime, NULL);
 			timersub(&aborttime, &currtime, &waittime);
@@ -2441,35 +2439,26 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 		/* Is the given timeout valid? */
 		if( !ptimeout || (waittime.tv_sec >= 0 && waittime.tv_usec >= 0) ){
 			/* Wait for the socket to become readable before checking again */
-			ret = rb_thread_fd_select( sd+1, &sd_rset, NULL, NULL, ptimeout ? &waittime : NULL );
+			ret = rb_wait_for_single_fd( sd, RB_WAITFD_IN, ptimeout ? &waittime : NULL );
 		} else {
 			ret = 0;
 		}
 
-
-#ifdef _WIN32
-		cleanup_crt_fd(&sd_rset, &crt_sd_rset);
-#endif
-
 		if ( ret < 0 ){
-			rb_fd_term( &sd_rset );
-			rb_sys_fail( "rb_thread_select()" );
+			rb_sys_fail( "rb_wait_for_single_fd()" );
 		}
 
 		/* Return false if the select() timed out */
 		if ( ret == 0 ){
-			rb_fd_term( &sd_rset );
 			return NULL;
 		}
 
 		/* Check for connection errors (PQisBusy is true on connection errors) */
 		if ( PQconsumeInput(conn) == 0 ){
-			rb_fd_term( &sd_rset );
 			rb_raise( rb_eConnectionBad, "PQconsumeInput() %s", PQerrorMessage(conn) );
 		}
 	}
 
-	rb_fd_term( &sd_rset );
 	return retval;
 }
 
@@ -2484,22 +2473,15 @@ notify_readable(PGconn *conn)
 
 /*
  * call-seq:
- *    conn.wait_for_notify( [ timeout ] ) -> String
- *    conn.wait_for_notify( [ timeout ] ) { |event, pid| block }
- *    conn.wait_for_notify( [ timeout ] ) { |event, pid, payload| block } # PostgreSQL 9.0
+ *    conn.wait_for_notify( [ timeout ] ) { |event, pid, payload| block } -> String
  *
  * Blocks while waiting for notification(s), or until the optional
  * _timeout_ is reached, whichever comes first.  _timeout_ is
  * measured in seconds and can be fractional.
  *
- * Returns +nil+ if _timeout_ is reached, the name of the NOTIFY
- * event otherwise.  If used in block form, passes the name of the
- * NOTIFY +event+ and the generating +pid+ into the block.
- *
- * Under PostgreSQL 9.0 and later, if the notification is sent with
- * the optional +payload+ string, it will be given to the block as the
- * third argument.
- *
+ * Returns +nil+ if _timeout_ is reached, the name of the NOTIFY event otherwise.
+ * If used in block form, passes the name of the NOTIFY +event+, the generating
+ * +pid+ and the optional +payload+ string into the block.
  */
 static VALUE
 pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
@@ -2528,12 +2510,10 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 	relname = rb_tainted_str_new2( pnotification->relname );
 	PG_ENCODING_SET_NOCHECK( relname, ENCODING_GET(self) );
 	be_pid = INT2NUM( pnotification->be_pid );
-#ifdef HAVE_ST_NOTIFY_EXTRA
 	if ( *pnotification->extra ) {
 		extra = rb_tainted_str_new2( pnotification->extra );
 		PG_ENCODING_SET_NOCHECK( extra, ENCODING_GET(self) );
 	}
-#endif
 	PQfreemem( pnotification );
 
 	if ( rb_block_given_p() )
@@ -2552,9 +2532,10 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
  * 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 received data fields from an Array of Strings. Optionally
- * the encoder can type cast the fields form various Ruby types in one step,
+ * _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.
@@ -2659,15 +2640,18 @@ pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    conn.get_copy_data( [ async = false [, decoder = nil ]] ) -> String
+ *    conn.get_copy_data( [ async = false [, decoder = nil ]] ) -> Object
  *
- * Return a string containing one row of data, +nil+
+ * Return one row of data, +nil+
  * if the copy is done, or +false+ if the call would
  * block (only possible if _async_ is true).
  *
- * decoder can be a PG::Coder derivation (typically PG::TextDecoder::CopyRow).
- * This decodes the received data fields as Array of Strings. Optionally
- * the decoder can type cast the fields to various Ruby types in one step,
+ * 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.
@@ -2968,11 +2952,9 @@ pgconn_set_client_encoding(VALUE self, VALUE str)
 	Check_Type(str, T_STRING);
 
 	if ( (gvl_PQsetClientEncoding(conn, StringValueCStr(str))) == -1 ) {
-		rb_raise(rb_ePGerror, "invalid encoding name: %s",StringValueCStr(str));
+		rb_raise(rb_ePGerror, "%s", PQerrorMessage(conn));
 	}
-#ifdef M17N_SUPPORTED
 	pgconn_set_internal_encoding_index( self );
-#endif
 
 	return Qnil;
 }
@@ -3100,10 +3082,6 @@ static VALUE
 pgconn_block( int argc, VALUE *argv, VALUE self ) {
 	PGconn *conn = pg_get_pgconn( self );
 
-	/* If WIN32 and Ruby 1.9 do not use rb_thread_select() which sometimes hangs
-	 * and does not wait (nor sleep) any time even if timeout is given.
-	 * Instead use the Winsock events and rb_w32_wait_events(). */
-
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
 	VALUE timeout_in;
@@ -3170,24 +3148,89 @@ pgconn_get_last_result(VALUE self)
 
 /*
  * call-seq:
- *    conn.async_exec(sql [, params, result_format ] ) -> PG::Result
- *    conn.async_exec(sql [, params, result_format ] ) {|pg_result| block }
+ *    conn.discard_results()
  *
- * This function has the same behavior as #exec,
+ * 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.
+ */
+static VALUE
+pgconn_discard_results(VALUE self)
+{
+	PGconn *conn = pg_get_pgconn(self);
+
+	PGresult *cur;
+	while ((cur = gvl_PQgetResult(conn)) != NULL) {
+		int 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);
+		}
+	}
+
+	return Qnil;
+}
+
+/*
+ * call-seq:
+ *    conn.async_exec(sql) -> PG::Result
+ *    conn.async_exec(sql) {|pg_result| block }
+ *
+ * This function has the same behavior as #sync_exec,
  * but is implemented using the asynchronous command
  * processing API of libpq.
+ *
+ * Both #sync_exec and #async_exec release the GVL while waiting for server response, so that concurrent threads will get executed.
+ * 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 thing like garbage collection, while queries are running like in this proposal: https://bugs.ruby-lang.org/issues/14723
  */
 static VALUE
 pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 {
 	VALUE rb_pgresult = Qnil;
 
-	/* remove any remaining results from the queue */
+	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 */
-	pgconn_get_last_result( self );
+	rb_pgresult = pgconn_get_last_result( self );
 
-	pgconn_send_query( argc, argv, self );
-	pgconn_block( 0, NULL, self );
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
+	}
+	return rb_pgresult;
+}
+
+
+/*
+ * call-seq:
+ *    conn.async_exec_params(sql, params [, result_format [, type_map ]] ) -> nil
+ *    conn.async_exec_params(sql, params [, result_format [, type_map ]] ) {|pg_result| block }
+ *
+ * This function has the same behavior as #sync_exec_params, but is implemented using the asynchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ */
+static VALUE
+pgconn_async_exec_params(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_pgresult = Qnil;
+
+	pgconn_discard_results( self );
+	/* If called with no or nil parameters, use PQsendQuery for compatibility */
+	if ( argc == 1 || (argc >= 2 && argc <= 4 && NIL_P(argv[1]) )) {
+		pg_deprecated(3, ("forwarding async_exec_params to async_exec is deprecated"));
+		pgconn_send_query( argc, argv, 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 );
 
 	if ( rb_block_given_p() ) {
@@ -3197,15 +3240,111 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 }
 
 
-#ifdef HAVE_PQSSLATTRIBUTE
-/* Since PostgreSQL-9.5: */
+/*
+ * call-seq:
+ *    conn.async_prepare(stmt_name, sql [, param_types ] ) -> PG::Result
+ *
+ * This function has the same behavior as #sync_prepare, but is implemented using the asynchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ */
+static VALUE
+pgconn_async_prepare(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_pgresult = Qnil;
+
+	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 );
+
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
+	}
+	return rb_pgresult;
+}
+
+
+/*
+ * call-seq:
+ *    conn.async_exec_prepared(statement_name [, params, result_format[, type_map]] ) -> PG::Result
+ *    conn.async_exec_prepared(statement_name [, params, result_format[, type_map]] ) {|pg_result| block }
+ *
+ * This function has the same behavior as #sync_exec_prepared, but is implemented using the asynchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ */
+static VALUE
+pgconn_async_exec_prepared(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_pgresult = Qnil;
+
+	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 );
 
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
+	}
+	return rb_pgresult;
+}
+
+
+/*
+ * call-seq:
+ *    conn.async_describe_portal( portal_name ) -> PG::Result
+ *
+ * This function has the same behavior as #sync_describe_portal, but is implemented using the asynchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ */
+static VALUE
+pgconn_async_describe_portal(VALUE self, VALUE portal)
+{
+	VALUE rb_pgresult = Qnil;
+
+	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 );
+
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
+	}
+	return rb_pgresult;
+}
+
+
+/*
+ * call-seq:
+ *    conn.async_describe_prepared( statement_name ) -> PG::Result
+ *
+ * This function has the same behavior as #sync_describe_prepared, but is implemented using the asynchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ */
+static VALUE
+pgconn_async_describe_prepared(VALUE self, VALUE stmt_name)
+{
+	VALUE rb_pgresult = Qnil;
+
+	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 );
+
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
+	}
+	return rb_pgresult;
+}
+
+
+#ifdef HAVE_PQSSLATTRIBUTE
 /*
  * call-seq:
  *    conn.ssl_in_use? -> Boolean
  *
  * Returns +true+ if the connection uses SSL, +false+ if not.
  *
+ * Available since PostgreSQL-9.5
  */
 static VALUE
 pgconn_ssl_in_use(VALUE self)
@@ -3238,6 +3377,8 @@ pgconn_ssl_in_use(VALUE self)
  *
  *
  * See also #ssl_attribute_names and http://www.postgresql.org/docs/current/interactive/libpq-status.html#LIBPQ-PQSSLATTRIBUTE
+ *
+ * Available since PostgreSQL-9.5
  */
 static VALUE
 pgconn_ssl_attribute(VALUE self, VALUE attribute_name)
@@ -3256,6 +3397,7 @@ pgconn_ssl_attribute(VALUE self, VALUE attribute_name)
  *
  * See also #ssl_attribute
  *
+ * Available since PostgreSQL-9.5
  */
 static VALUE
 pgconn_ssl_attribute_names(VALUE self)
@@ -3566,8 +3708,6 @@ pgconn_lounlink(VALUE self, VALUE in_oid)
 }
 
 
-#ifdef M17N_SUPPORTED
-
 void
 pgconn_set_internal_encoding_index( VALUE self )
 {
@@ -3718,7 +3858,7 @@ 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 )
-			rb_warn( "Failed to set the default_internal encoding to %s: '%s'",
+			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 );
@@ -3729,8 +3869,6 @@ pgconn_set_default_encoding( VALUE self )
 }
 
 
-#endif /* M17N_SUPPORTED */
-
 /*
  * call-seq:
  *    res.type_map_for_queries = typemap
@@ -3909,6 +4047,20 @@ pgconn_decoder_for_get_copy_data_get(VALUE self)
 	return this->decoder_for_get_copy_data;
 }
 
+/*
+ * call-seq:
+ *    res.guess_result_memsize = enabled
+ *
+ * This method is for testing only and will probably be removed in the future.
+ */
+static VALUE
+pgconn_guess_result_memsize_set(VALUE self, VALUE enable)
+{
+	t_pg_connection *this = pg_get_connection( self );
+	this->guess_result_memsize = RTEST(enable);
+	return enable;
+}
+
 
 /*
  * Document-class: PG::Connection
@@ -3939,9 +4091,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);
-#ifdef HAVE_PQPING
 	rb_define_singleton_method(rb_cPGconn, "ping", pgconn_s_ping, -1);
-#endif
 
 	/******     PG::Connection INSTANCE METHODS: Connection Control     ******/
 	rb_define_method(rb_cPGconn, "initialize", pgconn_init, -1);
@@ -3971,43 +4121,42 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "server_version", pgconn_server_version, 0);
 	rb_define_method(rb_cPGconn, "error_message", pgconn_error_message, 0);
 	rb_define_method(rb_cPGconn, "socket", pgconn_socket, 0);
-#if !defined(_WIN32) || defined(HAVE_RB_W32_WRAP_IO_HANDLE)
 	rb_define_method(rb_cPGconn, "socket_io", pgconn_socket_io, 0);
-#endif
 	rb_define_method(rb_cPGconn, "backend_pid", pgconn_backend_pid, 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, "exec", pgconn_exec, -1);
-	rb_define_alias(rb_cPGconn, "query", "exec");
-	rb_define_method(rb_cPGconn, "exec_params", pgconn_exec_params, -1);
-	rb_define_method(rb_cPGconn, "prepare", pgconn_prepare, -1);
-	rb_define_method(rb_cPGconn, "exec_prepared", pgconn_exec_prepared, -1);
-	rb_define_method(rb_cPGconn, "describe_prepared", pgconn_describe_prepared, 1);
-	rb_define_method(rb_cPGconn, "describe_portal", pgconn_describe_portal, 1);
+	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, "make_empty_pgresult", pgconn_make_empty_pgresult, 1);
 	rb_define_method(rb_cPGconn, "escape_string", pgconn_s_escape, 1);
 	rb_define_alias(rb_cPGconn, "escape", "escape_string");
-#ifdef HAVE_PQESCAPELITERAL
 	rb_define_method(rb_cPGconn, "escape_literal", pgconn_escape_literal, 1);
-#endif
-#ifdef HAVE_PQESCAPEIDENTIFIER
 	rb_define_method(rb_cPGconn, "escape_identifier", pgconn_escape_identifier, 1);
-#endif
 	rb_define_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
 	rb_define_method(rb_cPGconn, "unescape_bytea", pgconn_s_unescape_bytea, 1);
-#ifdef HAVE_PQSETSINGLEROWMODE
 	rb_define_method(rb_cPGconn, "set_single_row_mode", pgconn_set_single_row_mode, 0);
-#endif
 
 	/******     PG::Connection INSTANCE METHODS: Asynchronous Command Processing     ******/
 	rb_define_method(rb_cPGconn, "send_query", pgconn_send_query, -1);
+	rb_define_method(rb_cPGconn, "send_query_params", pgconn_send_query_params, -1);
+	rb_define_method(rb_cPGconn, "async_exec", pgconn_async_exec, -1);
+	rb_define_method(rb_cPGconn, "async_exec_params", pgconn_async_exec_params, -1);
+	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
 	rb_define_method(rb_cPGconn, "send_prepare", pgconn_send_prepare, -1);
+	rb_define_method(rb_cPGconn, "async_prepare", pgconn_async_prepare, -1);
 	rb_define_method(rb_cPGconn, "send_query_prepared", pgconn_send_query_prepared, -1);
+	rb_define_method(rb_cPGconn, "async_exec_prepared", pgconn_async_exec_prepared, -1);
 	rb_define_method(rb_cPGconn, "send_describe_prepared", pgconn_send_describe_prepared, 1);
+	rb_define_method(rb_cPGconn, "async_describe_prepared", pgconn_async_describe_prepared, 1);
 	rb_define_method(rb_cPGconn, "send_describe_portal", pgconn_send_describe_portal, 1);
+	rb_define_method(rb_cPGconn, "async_describe_portal", pgconn_async_describe_portal, 1);
 	rb_define_method(rb_cPGconn, "get_result", pgconn_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);
@@ -4015,6 +4164,7 @@ init_pg_connection()
 	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, "discard_results", pgconn_discard_results, 0);
 
 	/******     PG::Connection INSTANCE METHODS: Cancelling Queries in Progress     ******/
 	rb_define_method(rb_cPGconn, "cancel", pgconn_cancel, 0);
@@ -4031,6 +4181,7 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "set_error_verbosity", pgconn_set_error_verbosity, 1);
 	rb_define_method(rb_cPGconn, "trace", pgconn_trace, 1);
 	rb_define_method(rb_cPGconn, "untrace", pgconn_untrace, 0);
+	rb_define_method(rb_cPGconn, "guess_result_memsize=", pgconn_guess_result_memsize_set, 1);
 
 	/******     PG::Connection INSTANCE METHODS: Notice Processing     ******/
 	rb_define_method(rb_cPGconn, "set_notice_receiver", pgconn_set_notice_receiver, 0);
@@ -4045,9 +4196,10 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "wait_for_notify", pgconn_wait_for_notify, -1);
 	rb_define_alias(rb_cPGconn, "notifies_wait", "wait_for_notify");
 	rb_define_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
-	rb_define_method(rb_cPGconn, "async_exec", pgconn_async_exec, -1);
-	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
 	rb_define_method(rb_cPGconn, "get_last_result", pgconn_get_last_result, 0);
+#ifdef HAVE_PQENCRYPTPASSWORDCONN
+	rb_define_method(rb_cPGconn, "encrypt_password", pgconn_encrypt_password, -1);
+#endif
 
 #ifdef HAVE_PQSSLATTRIBUTE
 	rb_define_method(rb_cPGconn, "ssl_in_use?", pgconn_ssl_in_use, 0);
@@ -4083,12 +4235,10 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "lo_unlink", pgconn_lounlink, 1);
 	rb_define_alias(rb_cPGconn, "lounlink", "lo_unlink");
 
-#ifdef M17N_SUPPORTED
 	rb_define_method(rb_cPGconn, "internal_encoding", pgconn_internal_encoding, 0);
 	rb_define_method(rb_cPGconn, "internal_encoding=", pgconn_internal_encoding_set, 1);
 	rb_define_method(rb_cPGconn, "external_encoding", pgconn_external_encoding, 0);
 	rb_define_method(rb_cPGconn, "set_default_encoding", pgconn_set_default_encoding, 0);
-#endif /* M17N_SUPPORTED */
 
 	rb_define_method(rb_cPGconn, "type_map_for_queries=", pgconn_type_map_for_queries_set, 1);
 	rb_define_method(rb_cPGconn, "type_map_for_queries", pgconn_type_map_for_queries_get, 0);