pg 0.18.1 → 0.19.0

data/ext/errorcodes.txt

@@ -2,7 +2,7 @@
 # errcodes.txt
 #      PostgreSQL error codes
 #
-# Copyright (c) 2003-2013, PostgreSQL Global Development Group
+# Copyright (c) 2003-2016, PostgreSQL Global Development Group
 #
 # This list serves as the basis for generating source files containing error
 # codes. It is kept in a common format to make sure all these source files have
@@ -177,6 +177,8 @@ Section: Class 22 - Data Exception
 2201B    E    ERRCODE_INVALID_REGULAR_EXPRESSION                             invalid_regular_expression
 2201W    E    ERRCODE_INVALID_ROW_COUNT_IN_LIMIT_CLAUSE                      invalid_row_count_in_limit_clause
 2201X    E    ERRCODE_INVALID_ROW_COUNT_IN_RESULT_OFFSET_CLAUSE              invalid_row_count_in_result_offset_clause
+2202H    E    ERRCODE_INVALID_TABLESAMPLE_ARGUMENT                           invalid_tablesample_argument
+2202G    E    ERRCODE_INVALID_TABLESAMPLE_REPEAT                             invalid_tablesample_repeat
 22009    E    ERRCODE_INVALID_TIME_ZONE_DISPLACEMENT_VALUE                   invalid_time_zone_displacement_value
 2200C    E    ERRCODE_INVALID_USE_OF_ESCAPE_CHARACTER                        invalid_use_of_escape_character
 2200G    E    ERRCODE_MOST_SPECIFIC_TYPE_MISMATCH                            most_specific_type_mismatch
@@ -278,6 +280,7 @@ Section: Class 39 - External Routine Invocation Exception
 39004    E    ERRCODE_E_R_I_E_NULL_VALUE_NOT_ALLOWED                         null_value_not_allowed
 39P01    E    ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED                      trigger_protocol_violated
 39P02    E    ERRCODE_E_R_I_E_SRF_PROTOCOL_VIOLATED                          srf_protocol_violated
+39P03    E    ERRCODE_E_R_I_E_EVENT_TRIGGER_PROTOCOL_VIOLATED                event_trigger_protocol_violated
 
 Section: Class 3B - Savepoint Exception
 
@@ -454,6 +457,7 @@ P0000    E    ERRCODE_PLPGSQL_ERROR                                          plp
 P0001    E    ERRCODE_RAISE_EXCEPTION                                        raise_exception
 P0002    E    ERRCODE_NO_DATA_FOUND                                          no_data_found
 P0003    E    ERRCODE_TOO_MANY_ROWS                                          too_many_rows
+P0004    E    ERRCODE_ASSERT_FAILURE                                         assert_failure
 
 Section: Class XX - Internal Error
 

data/ext/extconf.rb

@@ -24,7 +24,11 @@ if enable_config("windows-cross")
 else
 	# Native build
 
-	if pgconfig = ( with_config('pg-config') || with_config('pg_config') || find_executable('pg_config') )
+	pgconfig = with_config('pg-config') ||
+		with_config('pg_config') ||
+		find_executable('pg_config')
+
+	if pgconfig && pgconfig != 'ignore'
 		$stderr.puts "Using config values from %s" % [ pgconfig ]
 		incdir = `"#{pgconfig}" --includedir`.chomp
 		libdir = `"#{pgconfig}" --libdir`.chomp
@@ -43,6 +47,9 @@ else
 	end
 end
 
+if RUBY_VERSION >= '2.3.0' && /solaris/ =~ RUBY_PLATFORM
+	append_cppflags( '-D__EXTENSIONS__' )
+end
 
 find_header( 'libpq-fe.h' ) or abort "Can't find the 'libpq-fe.h header"
 find_header( 'libpq/libpq-fs.h' ) or abort "Can't find the 'libpq/libpq-fs.h header"
@@ -73,7 +80,7 @@ have_func 'PQlibVersion'
 have_func 'PQping'
 have_func 'PQsetSingleRowMode'
 have_func 'PQconninfo'
-have_func 'PQhostaddr'
+have_func 'PQsslAttribute'
 
 have_func 'rb_encdb_alias'
 have_func 'rb_enc_alias'
@@ -93,8 +100,13 @@ $defs.push( "-DHAVE_ST_NOTIFY_EXTRA" ) if
 
 # unistd.h confilicts with ruby/win32.h when cross compiling for win32 and ruby 1.9.1
 have_header 'unistd.h'
+have_header 'inttypes.h'
 have_header 'ruby/st.h' or have_header 'st.h' or abort "pg currently requires the ruby/st.h header"
 
+checking_for "C99 variable length arrays" do
+	$defs.push( "-DHAVE_VARIABLE_LENGTH_ARRAYS" ) if try_compile('void test_vla(int l){ int vla[l]; }')
+end
+
 create_header()
 create_makefile( "pg_ext" )
 

data/ext/gvl_wrappers.h

@@ -195,6 +195,9 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 #define FOR_EACH_PARAM_OF_PQsendDescribePortal(param) \
 	param(PGconn *, conn)
 
+#define FOR_EACH_PARAM_OF_PQsetClientEncoding(param) \
+	param(PGconn *, conn)
+
 #define FOR_EACH_PARAM_OF_PQisBusy(param)
 
 #define FOR_EACH_PARAM_OF_PQcancel(param) \
@@ -226,6 +229,7 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 	function(PQsendQueryPrepared, GVL_TYPE_NONVOID, int, int, resultFormat) \
 	function(PQsendDescribePrepared, GVL_TYPE_NONVOID, int, const char *, stmt) \
 	function(PQsendDescribePortal, GVL_TYPE_NONVOID, int, const char *, portal) \
+	function(PQsetClientEncoding, GVL_TYPE_NONVOID, int, const char *, encoding) \
 	function(PQisBusy, GVL_TYPE_NONVOID, int, PGconn *, conn) \
 	function(PQcancel, GVL_TYPE_NONVOID, int, int, errbufsize);
 

data/ext/pg.c

@@ -1,12 +1,13 @@
 /*
  * pg.c - Toplevel extension
- * $Id: pg.c,v a9724aef9116 2014/12/12 21:03:27 lars $
+ * $Id: pg.c,v c77d0997b4e4 2016/08/20 17:30:03 ged $
  *
  * Author/s:
  *
  * - Jeff Davis <ruby-pg@j-davis.com>
  * - Guy Decoux (ts) <decoux@moulon.inra.fr>
  * - Michael Granger <ged@FaerieMUD.org>
+ * - Lars Kanis <lars@greiz-reinsdorf.de>
  * - Dave Lee
  * - Eiji Matsumoto <usagi@ruby.club.or.jp>
  * - Yukihiro Matsumoto <matz@ruby-lang.org>
@@ -15,10 +16,10 @@
  * See Contributors.rdoc for the many additional fine people that have contributed
  * to this library over the years.
  *
- * Copyright (c) 1997-2012 by the authors.
+ * Copyright (c) 1997-2016 by the authors.
  *
  * You may redistribute this software under the same terms as Ruby itself; see
- * http://www.ruby-lang.org/en/LICENSE.txt or the LICENSE file in the source
+ * https://www.ruby-lang.org/en/about/license.txt or the BSDL file in the source
  * for details.
  *
  * Portions of the code are from the PostgreSQL project, and are distributed
@@ -252,7 +253,7 @@ pg_get_rb_encoding_as_pg_encoding( rb_encoding *enc )
  *   char *current_out, *end_capa;
  *   PG_RB_STR_NEW( string, current_out, end_capa );
  *   while( data_is_going_to_be_processed ){
- *     PG_RB_STR_ENSURE_CAPA( string, 2 current_out, end_capa );
+ *     PG_RB_STR_ENSURE_CAPA( string, 2, current_out, end_capa );
  *     *current_out++ = databyte1;
  *     *current_out++ = databyte2;
  *   }

data/ext/pg.h

@@ -9,6 +9,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/types.h>
+#if !defined(_WIN32)
+#	include <sys/time.h>
+#endif
 #if defined(HAVE_UNISTD_H) && !defined(_WIN32)
 #	include <unistd.h>
 #endif /* HAVE_UNISTD_H */
@@ -133,6 +136,15 @@
 typedef long suseconds_t;
 #endif
 
+#if defined(HAVE_VARIABLE_LENGTH_ARRAYS)
+	#define PG_VARIABLE_LENGTH_ARRAY(type, name, len, maxlen) type name[(len)];
+#else
+	#define PG_VARIABLE_LENGTH_ARRAY(type, name, len, maxlen) \
+		type name[(maxlen)] = {(len)>(maxlen) ? (rb_raise(rb_eArgError, "Number of " #name " (%d) exceeds allowed maximum of " #maxlen, (len) ), (type)1) : (type)0};
+
+	#define PG_MAX_COLUMNS 4000
+#endif
+
 /* The data behind each PG::Connection object */
 typedef struct {
 	PGconn *pgconn;
@@ -196,7 +208,7 @@ typedef struct {
 } t_pg_result;
 
 
-typedef int (* t_pg_coder_enc_func)(t_pg_coder *, VALUE, char *, VALUE *);
+typedef int (* t_pg_coder_enc_func)(t_pg_coder *, VALUE, char *, VALUE *, int);
 typedef VALUE (* t_pg_coder_dec_func)(t_pg_coder *, char *, int, int, int, int);
 typedef VALUE (* t_pg_fit_to_result)(VALUE, VALUE);
 typedef VALUE (* t_pg_fit_to_query)(VALUE, VALUE);
@@ -312,7 +324,8 @@ void init_pg_binary_decoder                            _(( void ));
 VALUE lookup_error_class                               _(( const char * ));
 VALUE pg_bin_dec_bytea                                 _(( t_pg_coder*, char *, int, int, int, int ));
 VALUE pg_text_dec_string                               _(( t_pg_coder*, char *, int, int, int, int ));
-int pg_coder_enc_to_s                                  _(( t_pg_coder*, VALUE, char *, VALUE *));
+int pg_coder_enc_to_s                                  _(( t_pg_coder*, VALUE, char *, VALUE *, int));
+int pg_text_enc_identifier                             _(( t_pg_coder*, VALUE, char *, VALUE *, int));
 t_pg_coder_enc_func pg_coder_enc_func                  _(( t_pg_coder* ));
 t_pg_coder_dec_func pg_coder_dec_func                  _(( t_pg_coder*, int ));
 void pg_define_coder                                   _(( const char *, void *, VALUE, VALUE ));

data/ext/pg_binary_decoder.c

@@ -1,12 +1,14 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_binary_decoder.c,v 185638b52684 2014/11/08 20:43:53 lars $
+ * $Id: pg_binary_decoder.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
  *
  */
 
 #include "pg.h"
 #include "util.h"
+#ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
+#endif
 
 VALUE rb_mPG_BinaryDecoder;
 

data/ext/pg_binary_encoder.c

@@ -1,12 +1,14 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_binary_encoder.c,v ac23631c96d9 2014/10/14 11:50:21 lars $
+ * $Id: pg_binary_encoder.c,v e61a06f1f5ed 2015/12/25 21:14:21 lars $
  *
  */
 
 #include "pg.h"
 #include "util.h"
+#ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
+#endif
 
 VALUE rb_mPG_BinaryEncoder;
 
@@ -20,16 +22,16 @@ VALUE rb_mPG_BinaryEncoder;
  *
  */
 static int
-pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
-	char bool;
+	char mybool;
 	switch(value){
-		case Qtrue : bool = 1; break;
-		case Qfalse : bool = 0; break;
+		case Qtrue : mybool = 1; break;
+		case Qfalse : mybool = 0; break;
 		default :
 			rb_raise( rb_eTypeError, "wrong data for binary boolean converter" );
 	}
-	if(out) *out = bool;
+	if(out) *out = mybool;
 	return 1;
 }
 
@@ -42,7 +44,7 @@ pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
  *
  */
 static int
-pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		write_nbo16(NUM2INT(*intermediate), out);
@@ -61,7 +63,7 @@ pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
  *
  */
 static int
-pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		write_nbo32(NUM2LONG(*intermediate), out);
@@ -80,7 +82,7 @@ pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
  *
  */
 static int
-pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		write_nbo64(NUM2LL(*intermediate), out);
@@ -98,7 +100,7 @@ pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
  *
  */
 static int
-pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	int strlen;
 	VALUE subint;
@@ -107,13 +109,13 @@ pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermed
 
 	if(out){
 		/* Second encoder pass, if required */
-		strlen = enc_func(this->elem, value, out, intermediate);
+		strlen = enc_func(this->elem, value, out, intermediate, enc_idx);
 		strlen = base64_decode( out, out, strlen );
 
 		return strlen;
 	} else {
 		/* First encoder pass */
-		strlen = enc_func(this->elem, value, NULL, &subint);
+		strlen = enc_func(this->elem, value, NULL, &subint, enc_idx);
 
 		if( strlen == -1 ){
 			/* Encoded string is returned in subint */

data/ext/pg_coder.c

@@ -114,13 +114,24 @@ pg_composite_decoder_allocate( VALUE klass )
  *
  */
 static VALUE
-pg_coder_encode(VALUE self, VALUE value)
+pg_coder_encode(int argc, VALUE *argv, VALUE self)
 {
 	VALUE res;
 	VALUE intermediate;
+	VALUE value;
 	int len, len2;
+	int enc_idx;
 	t_pg_coder *this = DATA_PTR(self);
 
+	if(argc < 1 || argc > 2){
+		rb_raise(rb_eArgError, "wrong number of arguments (%i for 1..2)", argc);
+	}else if(argc == 1){
+		enc_idx = rb_ascii8bit_encindex();
+	}else{
+		enc_idx = rb_to_encoding_index(argv[1]);
+	}
+	value = argv[0];
+
 	if( NIL_P(value) )
 		return Qnil;
 
@@ -128,7 +139,7 @@ pg_coder_encode(VALUE self, VALUE value)
 		rb_raise(rb_eRuntimeError, "no encoder function defined");
 	}
 
-	len = this->enc_func( this, value, NULL, &intermediate );
+	len = this->enc_func( this, value, NULL, &intermediate, enc_idx );
 
 	if( len == -1 ){
 		/* The intermediate value is a String that can be used directly. */
@@ -137,7 +148,8 @@ pg_coder_encode(VALUE self, VALUE value)
 	}
 
 	res = rb_str_new(NULL, len);
-	len2 = this->enc_func( this, value, RSTRING_PTR(res), &intermediate);
+	PG_ENCODING_SET_NOCHECK(res, enc_idx);
+	len2 = this->enc_func( this, value, RSTRING_PTR(res), &intermediate, enc_idx );
 	if( len < len2 ){
 		rb_bug("%s: result length of first encoder run (%i) is less than second run (%i)",
 			rb_obj_classname( self ), len, len2 );
@@ -165,8 +177,8 @@ static VALUE
 pg_coder_decode(int argc, VALUE *argv, VALUE self)
 {
 	char *val;
-	VALUE tuple = -1;
-	VALUE field = -1;
+	int tuple = -1;
+	int field = -1;
 	VALUE res;
 	t_pg_coder *this = DATA_PTR(self);
 
@@ -359,10 +371,19 @@ pg_define_coder( const char *name, void *func, VALUE base_klass, VALUE nsp )
 
 
 static int
-pg_text_enc_in_ruby(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_in_ruby(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
-	*intermediate = rb_funcall( conv->coder_obj, s_id_encode, 1, value );
-	StringValue( *intermediate );
+	int arity = rb_obj_method_arity(conv->coder_obj, s_id_encode);
+	if( arity == 1 ){
+		VALUE out_str = rb_funcall( conv->coder_obj, s_id_encode, 1, value );
+		StringValue( out_str );
+		*intermediate = rb_str_export_to_enc(out_str, rb_enc_from_index(enc_idx));
+	}else{
+		VALUE enc = rb_enc_from_encoding(rb_enc_from_index(enc_idx));
+		VALUE out_str = rb_funcall( conv->coder_obj, s_id_encode, 2, value, enc );
+		StringValue( out_str );
+		*intermediate = out_str;
+	}
 	return -1;
 }
 
@@ -442,7 +463,7 @@ init_pg_coder()
 	 * This accessor is only used in PG::Coder#inspect .
 	 */
 	rb_define_attr(   rb_cPG_Coder, "name", 1, 1 );
-	rb_define_method( rb_cPG_Coder, "encode", pg_coder_encode, 1 );
+	rb_define_method( rb_cPG_Coder, "encode", pg_coder_encode, -1 );
 	rb_define_method( rb_cPG_Coder, "decode", pg_coder_decode, -1 );
 
 	/* Document-class: PG::SimpleCoder < PG::Coder */

data/ext/pg_connection.c

@@ -1,6 +1,6 @@
 /*
  * pg_connection.c - PG::Connection class extension
- * $Id: pg_connection.c,v a7befacdef4e 2014/12/12 20:57:14 lars $
+ * $Id: pg_connection.c,v 4d9c4ee44d11 2016/09/04 17:32:03 lars $
  *
  */
 
@@ -52,7 +52,7 @@ pg_get_connection( VALUE self )
  * Fetch the PG::Connection object data pointer and check it's
  * PGconn data pointer for sanity.
  */
-t_pg_connection *
+static t_pg_connection *
 pg_get_connection_safe( VALUE self )
 {
 	t_pg_connection *this;
@@ -88,7 +88,7 @@ pg_get_pgconn( VALUE self )
 /*
  * Close the associated socket IO object if there is one.
  */
-void
+static void
 pgconn_close_socket_io( VALUE self )
 {
 	t_pg_connection *this = pg_get_connection( self );
@@ -141,6 +141,16 @@ pgconn_make_conninfo_array( const PQconninfoOption *options )
 	return ary;
 }
 
+static const char *pg_cstr_enc(VALUE str, int enc_idx){
+	const char *ptr = StringValueCStr(str);
+	if( ENCODING_GET(str) == enc_idx ){
+		return ptr;
+	} else {
+		str = rb_str_export_to_enc(str, rb_enc_from_index(enc_idx));
+		return StringValueCStr(str);
+	}
+}
+
 
 /*
  * GC Mark function
@@ -373,7 +383,7 @@ pgconn_s_ping( int argc, VALUE *argv, VALUE klass )
 
 
 /*
- * Document-method: conndefaults
+ * Document-method: PG::Connection.conndefaults
  *
  * call-seq:
  *    PG::Connection.conndefaults() -> Array
@@ -627,22 +637,6 @@ pgconn_host(VALUE self)
 	return rb_tainted_str_new2(host);
 }
 
-#ifdef HAVE_PQHOSTADDR
-/*
- * call-seq:
- *    conn.hostaddr()
- *
- * Returns the server numeric IP address of the connection.
- */
-static VALUE
-pgconn_hostaddr(VALUE self)
-{
-	char *hostaddr = PQhostaddr(pg_get_pgconn(self));
-	if (!hostaddr) return Qnil;
-	return rb_tainted_str_new2(hostaddr);
-}
-#endif
-
 /*
  * call-seq:
  *    conn.port()
@@ -963,9 +957,9 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 
 	/* If called with no parameters, use PQexec */
 	if ( argc == 1 ) {
-		Check_Type(argv[0], T_STRING);
+		VALUE query_str = argv[0];
 
-		result = gvl_PQexec(conn, StringValueCStr(argv[0]));
+		result = gvl_PQexec(conn, pg_cstr_enc(query_str, ENCODING_GET(self)));
 		rb_pgresult = pg_new_result(result, self);
 		pg_result_check(rb_pgresult);
 		if (rb_block_given_p()) {
@@ -994,6 +988,10 @@ struct query_params_data {
 	 * Filled by caller
 	 */
 
+	/* The character encoding index of the connection. Any strings
+	 * given as query parameters are converted to this encoding.
+	 */
+	int enc_idx;
 	/* Is the query function to execute one with types array? */
 	int with_types;
 	/* Array of query params from user space */
@@ -1154,7 +1152,7 @@ alloc_query_params(struct query_params_data *paramsData)
 				VALUE intermediate;
 
 				/* 1st pass for retiving the required memory space */
-				int len = enc_func(conv, param_value, NULL, &intermediate);
+				int len = enc_func(conv, param_value, NULL, &intermediate, paramsData->enc_idx);
 
 				if( len == -1 ){
 					/* The intermediate value is a String that can be used directly. */
@@ -1178,7 +1176,7 @@ alloc_query_params(struct query_params_data *paramsData)
 					}
 
 					/* 2nd pass for writing the data to prepared buffer */
-					len = enc_func(conv, param_value, typecast_buf, &intermediate);
+					len = enc_func(conv, param_value, typecast_buf, &intermediate, paramsData->enc_idx);
 					paramsData->values[i] = typecast_buf;
 					if( paramsData->formats[i] == 0 ){
 						/* text format strings must be zero terminated and lengths are ignored */
@@ -1274,7 +1272,7 @@ pgconn_exec_params( int argc, VALUE *argv, VALUE self )
 	VALUE command, in_res_fmt;
 	int nParams;
 	int resultFormat;
-	struct query_params_data paramsData;
+	struct query_params_data paramsData = { ENCODING_GET(self) };
 
 	rb_scan_args(argc, argv, "13", &command, &paramsData.params, &in_res_fmt, &paramsData.typemap);
 	paramsData.with_types = 1;
@@ -1291,7 +1289,7 @@ pgconn_exec_params( int argc, VALUE *argv, VALUE self )
 	resultFormat = NIL_P(in_res_fmt) ? 0 : NUM2INT(in_res_fmt);
 	nParams = alloc_query_params( &paramsData );
 
-	result = gvl_PQexecParams(conn, StringValueCStr(command), nParams, paramsData.types,
+	result = gvl_PQexecParams(conn, pg_cstr_enc(command, paramsData.enc_idx), nParams, paramsData.types,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats, resultFormat);
 
 	free_query_params( &paramsData );
@@ -1337,10 +1335,13 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 	int i = 0;
 	int nParams = 0;
 	Oid *paramTypes = NULL;
+	const char *name_cstr;
+	const char *command_cstr;
+	int enc_idx = ENCODING_GET(self);
 
 	rb_scan_args(argc, argv, "21", &name, &command, &in_paramtypes);
-	Check_Type(name, T_STRING);
-	Check_Type(command, T_STRING);
+	name_cstr = pg_cstr_enc(name, enc_idx);
+	command_cstr = pg_cstr_enc(command, enc_idx);
 
 	if(! NIL_P(in_paramtypes)) {
 		Check_Type(in_paramtypes, T_ARRAY);
@@ -1354,8 +1355,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 				paramTypes[i] = NUM2UINT(param);
 		}
 	}
-	result = gvl_PQprepare(conn, StringValueCStr(name), StringValueCStr(command),
-			nParams, paramTypes);
+	result = gvl_PQprepare(conn, name_cstr, command_cstr, nParams, paramTypes);
 
 	xfree(paramTypes);
 
@@ -1408,11 +1408,10 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 	VALUE name, in_res_fmt;
 	int nParams;
 	int resultFormat;
-	struct query_params_data paramsData;
+	struct query_params_data paramsData = { ENCODING_GET(self) };
 
 	rb_scan_args(argc, argv, "13", &name, &paramsData.params, &in_res_fmt, &paramsData.typemap);
 	paramsData.with_types = 0;
-	Check_Type(name, T_STRING);
 
 	if(NIL_P(paramsData.params)) {
 		paramsData.params = rb_ary_new2(0);
@@ -1422,7 +1421,7 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 	resultFormat = NIL_P(in_res_fmt) ? 0 : NUM2INT(in_res_fmt);
 	nParams = alloc_query_params( &paramsData );
 
-	result = gvl_PQexecPrepared(conn, StringValueCStr(name), nParams,
+	result = gvl_PQexecPrepared(conn, pg_cstr_enc(name, paramsData.enc_idx), nParams,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats,
 		resultFormat);
 
@@ -1450,13 +1449,12 @@ pgconn_describe_prepared(VALUE self, VALUE stmt_name)
 	PGresult *result;
 	VALUE rb_pgresult;
 	PGconn *conn = pg_get_pgconn(self);
-	char *stmt;
-	if(stmt_name == Qnil) {
+	const char *stmt;
+	if(NIL_P(stmt_name)) {
 		stmt = NULL;
 	}
 	else {
-		Check_Type(stmt_name, T_STRING);
-		stmt = StringValueCStr(stmt_name);
+		stmt = pg_cstr_enc(stmt_name, ENCODING_GET(self));
 	}
 	result = gvl_PQdescribePrepared(conn, stmt);
 	rb_pgresult = pg_new_result(result, self);
@@ -1478,13 +1476,12 @@ pgconn_describe_portal(self, stmt_name)
 	PGresult *result;
 	VALUE rb_pgresult;
 	PGconn *conn = pg_get_pgconn(self);
-	char *stmt;
-	if(stmt_name == Qnil) {
+	const char *stmt;
+	if(NIL_P(stmt_name)) {
 		stmt = NULL;
 	}
 	else {
-		Check_Type(stmt_name, T_STRING);
-		stmt = StringValueCStr(stmt_name);
+		stmt = pg_cstr_enc(stmt_name, ENCODING_GET(self));
 	}
 	result = gvl_PQdescribePortal(conn, stmt);
 	rb_pgresult = pg_new_result(result, self);
@@ -1526,10 +1523,6 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
  * call-seq:
  *    conn.escape_string( str ) -> String
  *
- * Connection instance method for versions of 8.1 and higher of libpq
- * uses PQescapeStringConn, which is safer. Avoid calling as a class method,
- * the class method uses the deprecated PQescapeString() API function.
- *
  * Returns a SQL-safe version of the String _str_.
  * This is the preferred way to make strings safe for inclusion in
  * SQL queries.
@@ -1538,32 +1531,41 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
  * inside of SQL commands.
  *
  * Encoding of escaped string will be equal to client encoding of connection.
+ *
+ * NOTE: This class version of this method can only be used safely in client
+ * programs that use a single PostgreSQL connection at a time (in this case it can
+ * find out what it needs to know "behind the scenes"). It might give the wrong
+ * results if used in programs that use multiple database connections; use the
+ * same method on the connection object in such cases.
  */
 static VALUE
 pgconn_s_escape(VALUE self, VALUE string)
 {
-	char *escaped;
 	size_t size;
 	int error;
 	VALUE result;
+	int enc_idx;
+	int singleton = !rb_obj_is_kind_of(self, rb_cPGconn);
 
 	Check_Type(string, T_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));
+	}
 
-	escaped = ALLOC_N(char, RSTRING_LEN(string) * 2 + 1);
-	if(rb_obj_class(self) == rb_cPGconn) {
-		size = PQescapeStringConn(pg_get_pgconn(self), escaped,
+	result = rb_str_new(NULL, RSTRING_LEN(string) * 2 + 1);
+	PG_ENCODING_SET_NOCHECK(result, enc_idx);
+	if( !singleton ) {
+		size = PQescapeStringConn(pg_get_pgconn(self), RSTRING_PTR(result),
 			RSTRING_PTR(string), RSTRING_LEN(string), &error);
 		if(error) {
-			xfree(escaped);
 			rb_raise(rb_ePGerror, "%s", PQerrorMessage(pg_get_pgconn(self)));
 		}
 	} else {
-		size = PQescapeString(escaped, RSTRING_PTR(string), RSTRING_LENINT(string));
+		size = PQescapeString(RSTRING_PTR(result), RSTRING_PTR(string), RSTRING_LEN(string));
 	}
-	result = rb_str_new(escaped, size);
-	xfree(escaped);
+	rb_str_set_len(result, size);
 	OBJ_INFECT(result, string);
-	PG_ENCODING_SET_NOCHECK(result, ENCODING_GET( rb_obj_class(self) == rb_cPGconn ? self : string ));
 
 	return result;
 }
@@ -1572,13 +1574,6 @@ pgconn_s_escape(VALUE self, VALUE string)
  * call-seq:
  *   conn.escape_bytea( string ) -> String
  *
- * Connection instance method for versions of 8.1 and higher of libpq
- * uses PQescapeByteaConn, which is safer. Avoid calling as a class method,
- * the class method uses the deprecated PQescapeBytea() API function.
- *
- * Use the instance method version of this function, it is safer than the
- * class method.
- *
  * Escapes binary data for use within an SQL command with the type +bytea+.
  *
  * Certain byte values must be escaped (but all byte values may be escaped)
@@ -1591,6 +1586,12 @@ pgconn_s_escape(VALUE self, VALUE string)
  *
  * Consider using exec_params, which avoids the need for passing values inside of
  * SQL commands.
+ *
+ * NOTE: This class version of this method can only be used safely in client
+ * programs that use a single PostgreSQL connection at a time (in this case it can
+ * find out what it needs to know "behind the scenes"). It might give the wrong
+ * results if used in programs that use multiple database connections; use the
+ * same method on the connection object in such cases.
  */
 static VALUE
 pgconn_s_escape_bytea(VALUE self, VALUE str)
@@ -1603,7 +1604,7 @@ pgconn_s_escape_bytea(VALUE self, VALUE str)
 	from      = (unsigned char*)RSTRING_PTR(str);
 	from_len  = RSTRING_LEN(str);
 
-	if(rb_obj_class(self) == rb_cPGconn) {
+	if ( rb_obj_is_kind_of(self, rb_cPGconn) ) {
 		to = PQescapeByteaConn(pg_get_pgconn(self), from, from_len, &to_len);
 	} else {
 		to = PQescapeBytea( from, from_len, &to_len);
@@ -1659,8 +1660,12 @@ pgconn_escape_literal(VALUE self, VALUE string)
 	char *escaped = NULL;
 	VALUE error;
 	VALUE result = Qnil;
+	int enc_idx = ENCODING_GET(self);
 
 	Check_Type(string, T_STRING);
+	if( ENCODING_GET(string) != enc_idx ){
+		string = rb_str_export_to_enc(string, rb_enc_from_index(enc_idx));
+	}
 
 	escaped = PQescapeLiteral(conn, RSTRING_PTR(string), RSTRING_LEN(string));
 	if (escaped == NULL)
@@ -1673,7 +1678,7 @@ pgconn_escape_literal(VALUE self, VALUE string)
 	result = rb_str_new2(escaped);
 	PQfreemem(escaped);
 	OBJ_INFECT(result, string);
-	PG_ENCODING_SET_NOCHECK(result, ENCODING_GET(self));
+	PG_ENCODING_SET_NOCHECK(result, enc_idx);
 
 	return result;
 }
@@ -1686,8 +1691,9 @@ pgconn_escape_literal(VALUE self, VALUE string)
  *
  * Escape an arbitrary String +str+ as an identifier.
  *
- * This method does the same as #quote_ident, but uses libpq to
- * process the 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.
  */
 static VALUE
 pgconn_escape_identifier(VALUE self, VALUE string)
@@ -1696,8 +1702,12 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 	char *escaped = NULL;
 	VALUE error;
 	VALUE result = Qnil;
+	int enc_idx = ENCODING_GET(self);
 
 	Check_Type(string, T_STRING);
+	if( ENCODING_GET(string) != enc_idx ){
+		string = rb_str_export_to_enc(string, rb_enc_from_index(enc_idx));
+	}
 
 	escaped = PQescapeIdentifier(conn, RSTRING_PTR(string), RSTRING_LEN(string));
 	if (escaped == NULL)
@@ -1710,7 +1720,7 @@ pgconn_escape_identifier(VALUE self, VALUE string)
 	result = rb_str_new2(escaped);
 	PQfreemem(escaped);
 	OBJ_INFECT(result, string);
-	PG_ENCODING_SET_NOCHECK(result, ENCODING_GET(self));
+	PG_ENCODING_SET_NOCHECK(result, enc_idx);
 
 	return result;
 }
@@ -1818,15 +1828,14 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 	VALUE error;
 	int nParams;
 	int resultFormat;
-	struct query_params_data paramsData;
+	struct query_params_data paramsData = { ENCODING_GET(self) };
 
 	rb_scan_args(argc, argv, "13", &command, &paramsData.params, &in_res_fmt, &paramsData.typemap);
 	paramsData.with_types = 1;
-	Check_Type(command, T_STRING);
 
 	/* If called with no parameters, use PQsendQuery */
 	if(NIL_P(paramsData.params)) {
-		if(gvl_PQsendQuery(conn,StringValueCStr(command)) == 0) {
+		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);
@@ -1842,7 +1851,7 @@ pgconn_send_query(int argc, VALUE *argv, VALUE self)
 	resultFormat = NIL_P(in_res_fmt) ? 0 : NUM2INT(in_res_fmt);
 	nParams = alloc_query_params( &paramsData );
 
-	result = gvl_PQsendQueryParams(conn, StringValueCStr(command), nParams, paramsData.types,
+	result = gvl_PQsendQueryParams(conn, pg_cstr_enc(command, paramsData.enc_idx), nParams, paramsData.types,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats, resultFormat);
 
 	free_query_params( &paramsData );
@@ -1886,10 +1895,13 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	int i = 0;
 	int nParams = 0;
 	Oid *paramTypes = NULL;
+	const char *name_cstr;
+	const char *command_cstr;
+	int enc_idx = ENCODING_GET(self);
 
 	rb_scan_args(argc, argv, "21", &name, &command, &in_paramtypes);
-	Check_Type(name, T_STRING);
-	Check_Type(command, T_STRING);
+	name_cstr = pg_cstr_enc(name, enc_idx);
+	command_cstr = pg_cstr_enc(command, enc_idx);
 
 	if(! NIL_P(in_paramtypes)) {
 		Check_Type(in_paramtypes, T_ARRAY);
@@ -1903,8 +1915,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 				paramTypes[i] = NUM2UINT(param);
 		}
 	}
-	result = gvl_PQsendPrepare(conn, StringValueCStr(name), StringValueCStr(command),
-			nParams, paramTypes);
+	result = gvl_PQsendPrepare(conn, name_cstr, command_cstr, nParams, paramTypes);
 
 	xfree(paramTypes);
 
@@ -1957,11 +1968,10 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 	VALUE error;
 	int nParams;
 	int resultFormat;
-	struct query_params_data paramsData;
+	struct query_params_data paramsData = { ENCODING_GET(self) };
 
 	rb_scan_args(argc, argv, "13", &name, &paramsData.params, &in_res_fmt, &paramsData.typemap);
 	paramsData.with_types = 0;
-	Check_Type(name, T_STRING);
 
 	if(NIL_P(paramsData.params)) {
 		paramsData.params = rb_ary_new2(0);
@@ -1972,7 +1982,7 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 	resultFormat = NIL_P(in_res_fmt) ? 0 : NUM2INT(in_res_fmt);
 	nParams = alloc_query_params( &paramsData );
 
-	result = gvl_PQsendQueryPrepared(conn, StringValueCStr(name), nParams,
+	result = gvl_PQsendQueryPrepared(conn, pg_cstr_enc(name, paramsData.enc_idx), nParams,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats,
 		resultFormat);
 
@@ -1999,7 +2009,7 @@ pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 	VALUE error;
 	PGconn *conn = pg_get_pgconn(self);
 	/* returns 0 on failure */
-	if(gvl_PQsendDescribePrepared(conn,StringValueCStr(stmt_name)) == 0) {
+	if(gvl_PQsendDescribePrepared(conn, pg_cstr_enc(stmt_name, ENCODING_GET(self))) == 0) {
 		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
@@ -2021,7 +2031,7 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
 	VALUE error;
 	PGconn *conn = pg_get_pgconn(self);
 	/* returns 0 on failure */
-	if(gvl_PQsendDescribePortal(conn,StringValueCStr(portal)) == 0) {
+	if(gvl_PQsendDescribePortal(conn, pg_cstr_enc(portal, ENCODING_GET(self))) == 0) {
 		error = rb_exc_new2(rb_eUnableToSend, PQerrorMessage(conn));
 		rb_iv_set(error, "@connection", self);
 		rb_exc_raise(error);
@@ -2581,16 +2591,17 @@ pgconn_put_copy_data(int argc, VALUE *argv, VALUE self)
 
 	if( p_coder ){
 		t_pg_coder_enc_func enc_func;
+		int enc_idx = ENCODING_GET(self);
 
 		enc_func = pg_coder_enc_func( p_coder );
-		len = enc_func( p_coder, value, NULL, &intermediate );
+		len = enc_func( p_coder, value, NULL, &intermediate, enc_idx);
 
 		if( len == -1 ){
 			/* The intermediate value is a String that can be used directly. */
 			buffer = intermediate;
 		} else {
 			buffer = rb_str_new(NULL, len);
-			len = enc_func( p_coder, value, RSTRING_PTR(buffer), &intermediate);
+			len = enc_func( p_coder, value, RSTRING_PTR(buffer), &intermediate, enc_idx);
 			rb_str_set_len( buffer, len );
 		}
 	}
@@ -2629,13 +2640,13 @@ pgconn_put_copy_end(int argc, VALUE *argv, VALUE self)
 	VALUE str;
 	VALUE error;
 	int ret;
-	char *error_message = NULL;
+	const char *error_message = NULL;
 	PGconn *conn = pg_get_pgconn(self);
 
 	if (rb_scan_args(argc, argv, "01", &str) == 0)
 		error_message = NULL;
 	else
-		error_message = StringValueCStr(str);
+		error_message = pg_cstr_enc(str, ENCODING_GET(self));
 
 	ret = gvl_PQputCopyEnd(conn, error_message);
 	if(ret == -1) {
@@ -2956,7 +2967,7 @@ pgconn_set_client_encoding(VALUE self, VALUE str)
 
 	Check_Type(str, T_STRING);
 
-	if ( (PQsetClientEncoding(conn, StringValueCStr(str))) == -1 ) {
+	if ( (gvl_PQsetClientEncoding(conn, StringValueCStr(str))) == -1 ) {
 		rb_raise(rb_ePGerror, "invalid encoding name: %s",StringValueCStr(str));
 	}
 #ifdef M17N_SUPPORTED
@@ -3012,8 +3023,10 @@ pgconn_transaction(VALUE self)
 
 /*
  * call-seq:
- *    PG::Connection.quote_ident( str ) -> String
  *    conn.quote_ident( str ) -> String
+ *    conn.quote_ident( array ) -> String
+ *    PG::Connection.quote_ident( str ) -> String
+ *    PG::Connection.quote_ident( array ) -> String
  *
  * Returns a string that is safe for inclusion in a SQL query as an
  * identifier. Note: this is not a quote function for values, but for
@@ -3023,40 +3036,41 @@ pgconn_transaction(VALUE self)
  * The identifier <tt>FOO</tt> is folded to lower case, so it actually
  * means <tt>foo</tt>. If you really want to access the case-sensitive
  * field name <tt>FOO</tt>, use this function like
- * <tt>PG::Connection.quote_ident('FOO')</tt>, which will return <tt>"FOO"</tt>
+ * <tt>conn.quote_ident('FOO')</tt>, which will return <tt>"FOO"</tt>
  * (with double-quotes). PostgreSQL will see the double-quotes, and
  * it will not fold to lower case.
  *
  * Similarly, this function also protects against special characters,
  * and other things that might allow SQL injection if the identifier
  * comes from an untrusted source.
+ *
+ * If the parameter is an Array, then all it's values are separately quoted
+ * and then joined by a "." character. This can be used for identifiers in
+ * the form "schema"."table"."column" .
+ *
+ * This method is functional identical to the encoder PG::TextEncoder::Identifier .
+ *
+ * If the instance method form is used and the input string character encoding
+ * is different to the connection encoding, then the string is converted to this
+ * encoding, so that the returned string is always encoded as PG::Connection#internal_encoding .
+ *
+ * In the singleton form (PG::Connection.quote_ident) the character encoding
+ * of the result string is set to the character encoding of the input string.
  */
 static VALUE
-pgconn_s_quote_ident(VALUE self, VALUE in_str)
+pgconn_s_quote_ident(VALUE self, VALUE str_or_array)
 {
 	VALUE ret;
-	char *str = StringValuePtr(in_str);
-	/* result size at most NAMEDATALEN*2 plus surrounding
-	 * double-quotes. */
-	char buffer[NAMEDATALEN*2+2];
-	unsigned int i=0,j=0;
-	unsigned int str_len = RSTRING_LENINT(in_str);
-
-	if(str_len >= NAMEDATALEN) {
-		rb_raise(rb_eArgError,
-			"Input string is longer than NAMEDATALEN-1 (%d)",
-			NAMEDATALEN-1);
-	}
-	buffer[j++] = '"';
-	for(i = 0; i < str_len && str[i]; i++) {
-		if(str[i] == '"')
-			buffer[j++] = '"';
-		buffer[j++] = str[i];
-	}
-	buffer[j++] = '"';
-	ret = rb_str_new(buffer,j);
-	OBJ_INFECT(ret, in_str);
-	PG_ENCODING_SET_NOCHECK(ret, ENCODING_GET( rb_obj_class(self) == rb_cPGconn ? self : in_str ));
+	int enc_idx;
+
+	if( rb_obj_is_kind_of(self, rb_cPGconn) ){
+		enc_idx = ENCODING_GET( self );
+	}else{
+		enc_idx = RB_TYPE_P(str_or_array, T_STRING) ? ENCODING_GET( str_or_array ) : rb_ascii8bit_encindex();
+	}
+	pg_text_enc_identifier(NULL, str_or_array, NULL, &ret, enc_idx);
+
+	OBJ_INFECT(ret, str_or_array);
 
 	return ret;
 }
@@ -3182,6 +3196,84 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 	return rb_pgresult;
 }
 
+
+#ifdef HAVE_PQSSLATTRIBUTE
+/* Since PostgreSQL-9.5: */
+
+/*
+ * call-seq:
+ *    conn.ssl_in_use? -> Boolean
+ *
+ * Returns +true+ if the connection uses SSL, +false+ if not.
+ *
+ */
+static VALUE
+pgconn_ssl_in_use(VALUE self)
+{
+	return PQsslInUse(pg_get_pgconn(self)) ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ *    conn.ssl_attribute(attribute_name) -> String
+ *
+ * Returns SSL-related information about the connection.
+ *
+ * The list of available attributes varies depending on the SSL library being used,
+ * and the type of connection. If an attribute is not available, returns nil.
+ *
+ * The following attributes are commonly available:
+ *
+ * [+library+]
+ *   Name of the SSL implementation in use. (Currently, only "OpenSSL" is implemented)
+ * [+protocol+]
+ *   SSL/TLS version in use. Common values are "SSLv2", "SSLv3", "TLSv1", "TLSv1.1" and "TLSv1.2", but an implementation may return other strings if some other protocol is used.
+ * [+key_bits+]
+ *   Number of key bits used by the encryption algorithm.
+ * [+cipher+]
+ *   A short name of the ciphersuite used, e.g. "DHE-RSA-DES-CBC3-SHA". The names are specific to each SSL implementation.
+ * [+compression+]
+ *   If SSL compression is in use, returns the name of the compression algorithm, or "on" if compression is used but the algorithm is not known. If compression is not in use, returns "off".
+ *
+ *
+ * See also #ssl_attribute_names and http://www.postgresql.org/docs/current/interactive/libpq-status.html#LIBPQ-PQSSLATTRIBUTE
+ */
+static VALUE
+pgconn_ssl_attribute(VALUE self, VALUE attribute_name)
+{
+	const char *p_attr;
+
+	p_attr = PQsslAttribute(pg_get_pgconn(self), StringValueCStr(attribute_name));
+	return p_attr ? rb_str_new_cstr(p_attr) : Qnil;
+}
+
+/*
+ * call-seq:
+ *    conn.ssl_attribute_names -> Array<String>
+ *
+ * Return an array of SSL attribute names available.
+ *
+ * See also #ssl_attribute
+ *
+ */
+static VALUE
+pgconn_ssl_attribute_names(VALUE self)
+{
+	int i;
+	const char * const * p_list = PQsslAttributeNames(pg_get_pgconn(self));
+	VALUE ary = rb_ary_new();
+
+	for ( i = 0; p_list[i]; i++ ) {
+		rb_ary_push( ary, rb_str_new_cstr( p_list[i] ));
+	}
+	return ary;
+}
+
+
+#endif
+
+
 /**************************************************************************
  * LARGE OBJECT SUPPORT
  **************************************************************************/
@@ -3537,7 +3629,7 @@ pgconn_internal_encoding_set(VALUE self, VALUE enc)
 		rb_encoding *rbenc = rb_to_encoding( enc );
 		const char *name = pg_get_rb_encoding_as_pg_encoding( rbenc );
 
-		if ( PQsetClientEncoding(pg_get_pgconn( self ), name) == -1 ) {
+		if ( gvl_PQsetClientEncoding(pg_get_pgconn( self ), name) == -1 ) {
 			VALUE server_encoding = pgconn_external_encoding( self );
 			rb_raise( rb_eEncCompatError, "incompatible character encodings: %s and %s",
 					  rb_enc_name(rb_to_encoding(server_encoding)), name );
@@ -3579,6 +3671,34 @@ pgconn_external_encoding(VALUE self)
 }
 
 
+static VALUE
+pgconn_set_client_encoding_async1( VALUE args )
+{
+	VALUE self = ((VALUE*)args)[0];
+	VALUE encname = ((VALUE*)args)[1];
+	VALUE query_format = rb_str_new_cstr("set client_encoding to '%s'");
+	VALUE query = rb_funcall(query_format, rb_intern("%"), 1, encname);
+
+	pgconn_async_exec(1, &query, self);
+	return 0;
+}
+
+
+static VALUE
+pgconn_set_client_encoding_async2( VALUE arg )
+{
+	UNUSED(arg);
+	return 1;
+}
+
+
+static VALUE
+pgconn_set_client_encoding_async( VALUE self, const char *encname )
+{
+	VALUE args[] = { self, rb_str_new_cstr(encname) };
+	return rb_rescue(pgconn_set_client_encoding_async1, (VALUE)&args, pgconn_set_client_encoding_async2, Qnil);
+}
+
 
 /*
  * call-seq:
@@ -3597,7 +3717,7 @@ pgconn_set_default_encoding( VALUE self )
 
 	if (( enc = rb_default_internal_encoding() )) {
 		encname = pg_get_rb_encoding_as_pg_encoding( enc );
-		if ( PQsetClientEncoding(conn, encname) != 0 )
+		if ( pgconn_set_client_encoding_async(self, encname) != 0 )
 			rb_warn( "Failed to set the default_internal encoding to %s: '%s'",
 			         encname, PQerrorMessage(conn) );
 		pgconn_set_internal_encoding_index( self );
@@ -3729,7 +3849,7 @@ pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE typemap)
  *
  * Returns either:
  * * a kind of PG::Coder
- * * +nil+ - type encoding is disabled, returned data will be a String.
+ * * +nil+ - type encoding is disabled, data must be a String.
  *
  */
 static VALUE
@@ -3790,6 +3910,9 @@ pgconn_decoder_for_get_copy_data_get(VALUE self)
 }
 
 
+/*
+ * Document-class: PG::Connection
+ */
 void
 init_pg_connection()
 {
@@ -3835,9 +3958,6 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "user", pgconn_user, 0);
 	rb_define_method(rb_cPGconn, "pass", pgconn_pass, 0);
 	rb_define_method(rb_cPGconn, "host", pgconn_host, 0);
-#ifdef HAVE_PQHOSTADDR
-	rb_define_method(rb_cPGconn, "hostaddr", pgconn_hostaddr, 0);
-#endif
 	rb_define_method(rb_cPGconn, "port", pgconn_port, 0);
 	rb_define_method(rb_cPGconn, "tty", pgconn_tty, 0);
 #ifdef HAVE_PQCONNINFO
@@ -3929,6 +4049,12 @@ init_pg_connection()
 	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
 	rb_define_method(rb_cPGconn, "get_last_result", pgconn_get_last_result, 0);
 
+#ifdef HAVE_PQSSLATTRIBUTE
+	rb_define_method(rb_cPGconn, "ssl_in_use?", pgconn_ssl_in_use, 0);
+	rb_define_method(rb_cPGconn, "ssl_attribute", pgconn_ssl_attribute, 1);
+	rb_define_method(rb_cPGconn, "ssl_attribute_names", pgconn_ssl_attribute_names, 0);
+#endif
+
 	/******     PG::Connection INSTANCE METHODS: Large Object Support     ******/
 	rb_define_method(rb_cPGconn, "lo_creat", pgconn_locreat, -1);
 	rb_define_alias(rb_cPGconn, "locreat", "lo_creat");