pg 0.19.0 → 1.1.0

data/ext/pg_connection.c

@@ -1,6 +1,6 @@
 /*
  * pg_connection.c - PG::Connection class extension
- * $Id: pg_connection.c,v 4d9c4ee44d11 2016/09/04 17:32:03 lars $
+ * $Id: pg_connection.c,v e57f6b452eb3 2018/08/18 10:58:52 lars $
  *
  */
 
@@ -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,7 +84,7 @@ 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)
+#if defined(_WIN32)
 		int ruby_sd = NUM2INT(rb_funcall( socket_io, rb_intern("fileno"), 0 ));
 		if( rb_w32_unwrap_io_handle(ruby_sd) ){
 			rb_raise(rb_eConnectionBad, "Could not unwrap win32 socket handle");
@@ -209,6 +198,8 @@ pgconn_s_allocate( VALUE klass )
 	this->decoder_for_get_copy_data = Qnil;
 	this->trace_stream = Qnil;
 	this->external_encoding = Qnil;
+	this->socket = -1;
+	this->guess_result_memsize = 1;
 
 	return self;
 }
@@ -281,7 +272,6 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 	this = pg_get_connection( self );
 	conninfo = rb_funcall2( rb_cPGconn, rb_intern("parse_connect_args"), argc, argv );
 	this->pgconn = gvl_PQconnectdb(StringValueCStr(conninfo));
-
 	if(this->pgconn == NULL)
 		rb_raise(rb_ePGerror, "PQconnectdb() unable to allocate structure");
 
@@ -291,9 +281,11 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 		rb_exc_raise(error);
 	}
 
-#ifdef M17N_SUPPORTED
+	this->socket = PQsocket( this->pgconn );
+	if ( this->socket < 0 )
+		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
+
 	pgconn_set_default_encoding( self );
-#endif
 
 	if (rb_block_given_p()) {
 		return rb_ensure(rb_yield, self, pgconn_finish, self);
@@ -343,18 +335,21 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 		rb_exc_raise(error);
 	}
 
+	this->socket = PQsocket( this->pgconn );
+	if ( this->socket < 0 )
+		rb_raise(rb_eConnectionBad, "PQsocket() can't get socket descriptor");
+
 	if ( rb_block_given_p() ) {
 		return rb_ensure( rb_yield, rb_conn, pgconn_finish, rb_conn );
 	}
 	return rb_conn;
 }
 
-#ifdef HAVE_PQPING
 /*
  * call-seq:
- *    PG::Connection.ping(connection_hash)       -> Fixnum
- *    PG::Connection.ping(connection_string)     -> Fixnum
- *    PG::Connection.ping(host, port, options, tty, dbname, login, password) ->  Fixnum
+ *    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.
  *
@@ -367,6 +362,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 +376,6 @@ pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
 
 	return INT2FIX((int)ping);
 }
-#endif
 
 
 /*
@@ -418,16 +414,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
- * send commands like: +ALTER USER joe PASSWORD 'pwd'+.
- * The arguments are the cleartext password, and the SQL name
- * of the user it is for.
+ * 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
+ */
+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)
@@ -457,7 +502,7 @@ pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
 
 /*
  * call-seq:
- *    conn.connect_poll() -> Fixnum
+ *    conn.connect_poll() -> Integer
  *
  * Returns one of:
  * [+PGRES_POLLING_READING+]
@@ -566,7 +611,7 @@ pgconn_reset_start(VALUE self)
 
 /*
  * call-seq:
- *    conn.reset_poll -> Fixnum
+ *    conn.reset_poll -> Integer
  *
  * Checks the status of a connection reset operation.
  * See #connect_start and #connect_poll for
@@ -613,7 +658,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 +731,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 )
@@ -805,7 +851,9 @@ pgconn_error_message(VALUE self)
 
 /*
  * call-seq:
- *    conn.socket() -> Fixnum
+ *    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.
@@ -815,7 +863,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 +875,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)
@@ -865,10 +908,8 @@ pgconn_socket_io(VALUE self)
 
 		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,11 +917,9 @@ pgconn_socket_io(VALUE self)
 	return socket_io;
 }
 
-#endif
-
 /*
  * call-seq:
- *    conn.backend_pid() -> Fixnum
+ *    conn.backend_pid() -> Integer
  *
  * Returns the process ID of the backend server
  * process for this connection.
@@ -941,9 +980,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 +994,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 +1006,10 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 		}
 		return rb_pgresult;
 	}
+	pg_deprecated(("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 );
 
 }
 
@@ -1234,8 +1272,8 @@ pgconn_query_assign_typemap( VALUE self, struct query_params_data *paramsData )
  * Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
- *      :type   => Fixnum (oid of type of bind parameter)
- *      :format => Fixnum (0 for text, 1 for binary)
+ *      :type   => Integer (oid of type of bind parameter)
+ *      :format => Integer (0 for text, 1 for binary)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :type => 0, :format => 0 }
@@ -1254,7 +1292,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 +1312,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(("forwarding exec_params to exec is deprecated"));
 		return pgconn_exec( 1, argv, self );
 	}
 	pgconn_query_assign_typemap( self, &paramsData );
@@ -1377,7 +1417,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  * SQL query. Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
- *      :format => Fixnum (0 for text, 1 for binary)
+ *      :format => Integer (0 for text, 1 for binary)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :format => 0 }
@@ -1390,7 +1430,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 +1587,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 +1686,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 +1703,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 +1723,7 @@ pgconn_escape_literal(VALUE self, VALUE string)
 
 	return result;
 }
-#endif
 
-#ifdef HAVE_PQESCAPEIDENTIFIER
 /*
  * call-seq:
  *    conn.escape_identifier( str ) -> String
@@ -1694,6 +1733,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 +1745,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 +1765,7 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 
 	return result;
 }
-#endif
 
-#ifdef HAVE_PQSETSINGLEROWMODE
 /*
  * call-seq:
  *    conn.set_single_row_mode -> self
@@ -1763,6 +1802,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,22 +1819,60 @@ 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) -> nil
+ *
+ * Sends SQL query request specified by _sql_ to PostgreSQL for
+ * asynchronous processing, and immediately returns.
+ * On failure, it raises a PG::Error.
+ *
+ * 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(("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(sql [, params, result_format[, type_map ]] ) -> nil
+ *    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 optional array of the bind parameters for the SQL query.
+ * +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)
- *      :type   => Fixnum (oid of type of bind parameter)
- *      :format => Fixnum (0 for text, 1 for binary)
+ *      :type   => Integer (oid of type of bind parameter)
+ *      :format => Integer (0 for text, 1 for binary)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :type => 0, :format => 0 }
@@ -1813,14 +1891,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 +1908,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 );
@@ -1940,7 +2004,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
  * SQL query. Each element of the +params+ array may be either:
  *   a hash of the form:
  *     {:value  => String (value of bind parameter)
- *      :format => Fixnum (0 for text, 1 for binary)
+ *      :format => Integer (0 for text, 1 for binary)
  *     }
  *   or, it may be a String. If it is a string, that is equivalent to the hash:
  *     { :value => <string value>, :format => 0 }
@@ -1953,7 +2017,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 +2267,6 @@ pgconn_flush(self)
 static VALUE
 pgconn_cancel(VALUE self)
 {
-#ifdef HAVE_PQGETCANCEL
 	char errbuf[256];
 	PGcancel *cancel;
 	VALUE retval;
@@ -2221,9 +2284,6 @@ pgconn_cancel(VALUE self)
 
 	PQfreeCancel(cancel);
 	return retval;
-#else
-	rb_notimplement();
-#endif
 }
 
 
@@ -2267,69 +2327,25 @@ 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 *) )
+wait_socket_readable( t_pg_connection *this, struct timeval *ptimeout, void *(*is_readable)(PGconn *) )
 {
-	int sd = PQsocket( conn );
+	PGconn *conn = this->pgconn;
 	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) */
@@ -2344,7 +2360,7 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 	}
 
 	while ( !(retval=is_readable(conn)) ) {
-		if ( WSAEventSelect(sd, hEvent, FD_READ|FD_CLOSE) == SOCKET_ERROR ) {
+		if ( WSAEventSelect(this->socket, hEvent, FD_READ|FD_CLOSE) == SOCKET_ERROR ) {
 			WSACloseEvent( hEvent );
 			rb_raise( rb_eConnectionBad, "WSAEventSelect socket error: %d", WSAGetLastError() );
 		}
@@ -2393,46 +2409,26 @@ 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 *))
+wait_socket_readable( t_pg_connection *this, struct timeval *ptimeout, void *(*is_readable)(PGconn *))
 {
-	int sd = PQsocket( conn );
+	PGconn *conn = this->pgconn;
 	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");
 
 	/* Check for connection errors (PQisBusy is true on connection errors) */
 	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 +2437,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( this->socket, 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,27 +2471,20 @@ 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)
 {
-	PGconn *conn = pg_get_pgconn( self );
+	t_pg_connection *this = pg_get_connection_safe( self );
 	PGnotify *pnotification;
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
@@ -2520,7 +2500,7 @@ pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
 		ptimeout = &timeout;
 	}
 
-	pnotification = (PGnotify*) wait_socket_readable( conn, ptimeout, notify_readable);
+	pnotification = (PGnotify*) wait_socket_readable( this, ptimeout, notify_readable);
 
 	/* Return nil if the select timed out */
 	if ( !pnotification ) return Qnil;
@@ -2528,12 +2508,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 +2530,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 +2638,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.
@@ -2724,7 +2706,7 @@ pgconn_get_copy_data(int argc, VALUE *argv, VALUE self )
 
 /*
  * call-seq:
- *    conn.set_error_verbosity( verbosity ) -> Fixnum
+ *    conn.set_error_verbosity( verbosity ) -> Integer
  *
  * Sets connection's verbosity to _verbosity_ and returns
  * the previous setting. Available settings are:
@@ -2968,11 +2950,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;
 }
@@ -3098,11 +3078,7 @@ get_result_readable(PGconn *conn)
  */
 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(). */
+	t_pg_connection *this = pg_get_connection_safe( self );
 
 	struct timeval timeout;
 	struct timeval *ptimeout = NULL;
@@ -3117,7 +3093,7 @@ pgconn_block( int argc, VALUE *argv, VALUE self ) {
 		ptimeout = &timeout;
 	}
 
-	ret = wait_socket_readable( conn, ptimeout, get_result_readable);
+	ret = wait_socket_readable( this, ptimeout, get_result_readable);
 
 	if( !ret )
 		return Qfalse;
@@ -3170,24 +3146,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(("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 +3238,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 +3375,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 +3395,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)
@@ -3280,7 +3420,7 @@ pgconn_ssl_attribute_names(VALUE self)
 
 /*
  * call-seq:
- *    conn.lo_creat( [mode] ) -> Fixnum
+ *    conn.lo_creat( [mode] ) -> Integer
  *
  * Creates a large object with mode _mode_. Returns a large object Oid.
  * On failure, it raises PG::Error.
@@ -3307,7 +3447,7 @@ pgconn_locreat(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    conn.lo_create( oid ) -> Fixnum
+ *    conn.lo_create( oid ) -> Integer
  *
  * Creates a large object with oid _oid_. Returns the large object Oid.
  * On failure, it raises PG::Error.
@@ -3328,7 +3468,7 @@ pgconn_locreate(VALUE self, VALUE in_lo_oid)
 
 /*
  * call-seq:
- *    conn.lo_import(file) -> Fixnum
+ *    conn.lo_import(file) -> Integer
  *
  * Import a file to a large object. Returns a large object Oid.
  *
@@ -3373,7 +3513,7 @@ pgconn_loexport(VALUE self, VALUE lo_oid, VALUE filename)
 
 /*
  * call-seq:
- *    conn.lo_open( oid, [mode] ) -> Fixnum
+ *    conn.lo_open( oid, [mode] ) -> Integer
  *
  * Open a large object of _oid_. Returns a large object descriptor
  * instance on success. The _mode_ argument specifies the mode for
@@ -3404,7 +3544,7 @@ pgconn_loopen(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    conn.lo_write( lo_desc, buffer ) -> Fixnum
+ *    conn.lo_write( lo_desc, buffer ) -> Integer
  *
  * Writes the string _buffer_ to the large object _lo_desc_.
  * Returns the number of bytes written.
@@ -3471,7 +3611,7 @@ pgconn_loread(VALUE self, VALUE in_lo_desc, VALUE in_len)
 
 /*
  * call-seq:
- *    conn.lo_lseek( lo_desc, offset, whence ) -> Fixnum
+ *    conn.lo_lseek( lo_desc, offset, whence ) -> Integer
  *
  * Move the large object pointer _lo_desc_ to offset _offset_.
  * Valid values for _whence_ are +SEEK_SET+, +SEEK_CUR+, and +SEEK_END+.
@@ -3493,7 +3633,7 @@ pgconn_lolseek(VALUE self, VALUE in_lo_desc, VALUE offset, VALUE whence)
 
 /*
  * call-seq:
- *    conn.lo_tell( lo_desc ) -> Fixnum
+ *    conn.lo_tell( lo_desc ) -> Integer
  *
  * Returns the current position of the large object _lo_desc_.
  */
@@ -3566,8 +3706,6 @@ pgconn_lounlink(VALUE self, VALUE in_oid)
 }
 
 
-#ifdef M17N_SUPPORTED
-
 void
 pgconn_set_internal_encoding_index( VALUE self )
 {
@@ -3718,7 +3856,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 +3867,6 @@ pgconn_set_default_encoding( VALUE self )
 }
 
 
-#endif /* M17N_SUPPORTED */
-
 /*
  * call-seq:
  *    res.type_map_for_queries = typemap
@@ -3909,6 +4045,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 +4089,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 +4119,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 +4162,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 +4179,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 +4194,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 +4233,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);