pg 1.6.3 → 1.7.0

data/ext/pg_connection.c

@@ -14,7 +14,7 @@ VALUE rb_cPGconn;
 static ID s_id_encode;
 static ID s_id_autoclose_set;
 static VALUE sym_type, sym_format, sym_value;
-static VALUE sym_symbol, sym_string, sym_static_symbol;
+static VALUE sym_symbol, sym_string;
 
 static VALUE pgconn_finish( VALUE );
 static VALUE pgconn_set_default_encoding( VALUE self );
@@ -153,13 +153,13 @@ pgconn_make_conninfo_array( const PQconninfoOption *options )
 	return ary;
 }
 
-static const char *pg_cstr_enc(VALUE str, int enc_idx){
+static const char *pg_cstr_enc(VALUE str, int enc_idx, VALUE *transcoded_str){
 	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);
+		*transcoded_str = rb_str_export_to_enc(str, rb_enc_from_index(enc_idx));
+		return StringValueCStr(*transcoded_str);
 	}
 }
 
@@ -188,6 +188,7 @@ pgconn_gc_compact( void *_this )
 	pg_gc_location( this->socket_io );
 	pg_gc_location( this->notice_receiver );
 	pg_gc_location( this->notice_processor );
+	pg_gc_location( this->self );
 	pg_gc_location( this->type_map_for_queries );
 	pg_gc_location( this->type_map_for_results );
 	pg_gc_location( this->trace_stream );
@@ -260,6 +261,7 @@ pgconn_s_allocate( VALUE klass )
 	RB_OBJ_WRITE(self, &this->socket_io, Qnil);
 	RB_OBJ_WRITE(self, &this->notice_receiver, Qnil);
 	RB_OBJ_WRITE(self, &this->notice_processor, Qnil);
+	RB_OBJ_WRITE(self, &this->self, self);
 	RB_OBJ_WRITE(self, &this->type_map_for_queries, pg_typemap_all_strings);
 	RB_OBJ_WRITE(self, &this->type_map_for_results, pg_typemap_all_strings);
 	RB_OBJ_WRITE(self, &this->encoder_for_put_copy_data, Qnil);
@@ -280,7 +282,8 @@ pgconn_s_sync_connect(int argc, VALUE *argv, VALUE klass)
 
 	this = pg_get_connection( self );
 	conninfo = rb_funcall2( rb_cPGconn, rb_intern("parse_connect_args"), argc, argv );
-	this->pgconn = gvl_PQconnectdb(StringValueCStr(conninfo));
+	this->pgconn = PQconnectdb(StringValueCStr(conninfo));
+	RB_GC_GUARD(conninfo);
 
 	if(this->pgconn == NULL)
 		rb_raise(rb_ePGerror, "PQconnectdb() unable to allocate PGconn structure");
@@ -329,6 +332,7 @@ pgconn_s_connect_start( int argc, VALUE *argv, VALUE klass )
 	this = pg_get_connection( rb_conn );
 	conninfo = rb_funcall2( klass, rb_intern("parse_connect_args"), argc, argv );
 	this->pgconn = gvl_PQconnectStart( StringValueCStr(conninfo) );
+	RB_GC_GUARD(conninfo);
 
 	if( this->pgconn == NULL )
 		rb_raise(rb_ePGerror, "PQconnectStart() unable to allocate PGconn structure");
@@ -350,6 +354,7 @@ pgconn_s_sync_ping( int argc, VALUE *argv, VALUE klass )
 
 	conninfo = rb_funcall2( klass, rb_intern("parse_connect_args"), argc, argv );
 	ping     = gvl_PQping( StringValueCStr(conninfo) );
+	RB_GC_GUARD(conninfo);
 
 	return INT2FIX((int)ping);
 }
@@ -434,7 +439,7 @@ pgconn_sync_encrypt_password(int argc, VALUE *argv, VALUE self)
 	Check_Type(password, T_STRING);
 	Check_Type(username, T_STRING);
 
-	encrypted = gvl_PQencryptPasswordConn(conn, StringValueCStr(password), StringValueCStr(username), RTEST(algorithm) ? StringValueCStr(algorithm) : NULL);
+	encrypted = PQencryptPasswordConn(conn, StringValueCStr(password), StringValueCStr(username), RTEST(algorithm) ? StringValueCStr(algorithm) : NULL);
 	if ( encrypted ) {
 		rval = rb_str_new2( encrypted );
 		PQfreemem( encrypted );
@@ -560,7 +565,7 @@ static VALUE
 pgconn_sync_reset( VALUE self )
 {
 	pgconn_close_socket_io( self );
-	gvl_PQreset( pg_get_pgconn(self) );
+	PQreset( pg_get_pgconn(self) );
 	return self;
 }
 
@@ -568,13 +573,17 @@ static VALUE
 pgconn_reset_start2( VALUE self, VALUE conninfo )
 {
 	t_pg_connection *this = pg_get_connection( self );
+	/* Ensure conninfo is a valid C string before closing the connection. */
+	char *p_conninfo = StringValueCStr(conninfo);
 
 	/* Close old connection */
 	pgconn_close_socket_io( self );
 	PQfinish( this->pgconn );
+	this->pgconn = NULL; /* Ensure no double free can happen. */
 
 	/* Start new connection */
-	this->pgconn = gvl_PQconnectStart( StringValueCStr(conninfo) );
+	this->pgconn = gvl_PQconnectStart( p_conninfo );
+	RB_GC_GUARD(conninfo);
 
 	if( this->pgconn == NULL )
 		rb_raise(rb_ePGerror, "PQconnectStart() unable to allocate PGconn structure");
@@ -865,6 +874,33 @@ pgconn_protocol_version(VALUE self)
 	return INT2NUM(protocol_version);
 }
 
+#ifdef LIBPQ_HAS_FULL_PROTOCOL_VERSION
+/*
+ * call-seq:
+ *   conn.full_protocol_version -> Integer
+ *
+ * Interrogates the frontend/backend protocol being used, including minor version.
+ *
+ * Applications might wish to use this function to determine whether certain features are supported.
+ * The result is the major version multiplied by 10000 added to the minor version, e.g. 30002 for version 3.2.
+ * The protocol version will not change after connection startup is complete, but it could theoretically change during a connection reset.
+ * The 3.0 protocol is supported by PostgreSQL server versions 7.4 and above.
+ *
+ * PG::ConnectionBad is raised if the connection is bad.
+ *
+ * Available since PostgreSQL-18.
+ */
+static VALUE
+pgconn_full_protocol_version(VALUE self)
+{
+	int protocol_version = PQfullProtocolVersion(pg_get_pgconn(self));
+	if (protocol_version == 0) {
+		pg_raise_conn_error( rb_eConnectionBad, self, "PQfullProtocolVersion() can't get protocol version");
+	}
+	return INT2NUM(protocol_version);
+}
+#endif
+
 /*
  * call-seq:
  *   conn.server_version -> Integer
@@ -1013,7 +1049,7 @@ pgconn_backend_pid(VALUE self)
 	return INT2NUM(PQbackendPID(pg_get_pgconn(self)));
 }
 
-#ifndef HAVE_PQSETCHUNKEDROWSMODE
+#ifndef LIBPQ_HAS_CHUNK_MODE
 typedef struct
 {
 	struct sockaddr_storage addr;
@@ -1100,11 +1136,11 @@ static VALUE pgconn_sync_exec_params( int, VALUE *, VALUE );
  * This function has the same behavior as #async_exec, but is implemented using the synchronous command processing API of libpq.
  * It's not recommended to use explicit sync or async variants but #exec instead, unless you have a good reason to do so.
  *
- * 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:
+ * However #async_exec has some 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 and can pass them through <tt>Fiber.scheduler</tt>.
+ * 1. Only #async_exec allows concurrent threads to run, while waiting for a server response.
+ * 2. #async_exec can be aborted by signals (like Ctrl-C), while #exec blocks signal processing until the query is answered.
+ * 3. Ruby VM gets notified about IO blocked operations and can pass them through <tt>Fiber.scheduler</tt>.
  *    So only <tt>async_*</tt> methods are compatible to event based schedulers like the async gem.
  */
 static VALUE
@@ -1117,8 +1153,10 @@ pgconn_sync_exec(int argc, VALUE *argv, VALUE self)
 	/* 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];
+		VALUE transcoded_str;
 
-		result = gvl_PQexec(this->pgconn, pg_cstr_enc(query_str, this->enc_idx));
+		result = PQexec(this->pgconn, pg_cstr_enc(query_str, this->enc_idx, &transcoded_str));
+		RB_GC_GUARD(transcoded_str);
 		rb_pgresult = pg_new_result(result, self);
 		pg_result_check(rb_pgresult);
 		if (rb_block_given_p()) {
@@ -1256,7 +1294,7 @@ alloc_query_params(struct query_params_data *paramsData)
 	int nParams;
 	int i=0;
 	t_pg_coder *conv;
-	unsigned int required_pool_size;
+	size_t required_pool_size;
 	char *memory_pool;
 
 	Check_Type(paramsData->params, T_ARRAY);
@@ -1268,7 +1306,7 @@ alloc_query_params(struct query_params_data *paramsData)
 	paramsData->typecast_heap_chain = Qnil;
 	paramsData->gc_array = Qnil;
 
-	nParams = (int)RARRAY_LEN(paramsData->params);
+	nParams = RARRAY_LENINT(paramsData->params);
 
 	required_pool_size = nParams * (
 			sizeof(char *) +
@@ -1415,6 +1453,7 @@ pgconn_sync_exec_params( int argc, VALUE *argv, VALUE self )
 	PGresult *result = NULL;
 	VALUE rb_pgresult;
 	VALUE command, in_res_fmt;
+	VALUE transcoded_str;
 	int nParams;
 	int resultFormat;
 	struct query_params_data paramsData = { this->enc_idx };
@@ -1436,9 +1475,10 @@ pgconn_sync_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(this->pgconn, pg_cstr_enc(command, paramsData.enc_idx), nParams, paramsData.types,
+	result = PQexecParams(this->pgconn, pg_cstr_enc(command, paramsData.enc_idx, &transcoded_str), nParams, paramsData.types,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats, resultFormat);
 
+	RB_GC_GUARD(transcoded_str);
 	free_query_params( &paramsData );
 
 	rb_pgresult = pg_new_result(result, self);
@@ -1467,6 +1507,7 @@ pgconn_sync_prepare(int argc, VALUE *argv, VALUE self)
 	VALUE rb_pgresult;
 	VALUE name, command, in_paramtypes;
 	VALUE param;
+	VALUE transcoded_str1, transcoded_str2;
 	int i = 0;
 	int nParams = 0;
 	Oid *paramTypes = NULL;
@@ -1475,12 +1516,12 @@ pgconn_sync_prepare(int argc, VALUE *argv, VALUE self)
 	int enc_idx = this->enc_idx;
 
 	rb_scan_args(argc, argv, "21", &name, &command, &in_paramtypes);
-	name_cstr = pg_cstr_enc(name, enc_idx);
-	command_cstr = pg_cstr_enc(command, enc_idx);
+	name_cstr = pg_cstr_enc(name, enc_idx, &transcoded_str1);
+	command_cstr = pg_cstr_enc(command, enc_idx, &transcoded_str2);
 
 	if(! NIL_P(in_paramtypes)) {
 		Check_Type(in_paramtypes, T_ARRAY);
-		nParams = (int)RARRAY_LEN(in_paramtypes);
+		nParams = RARRAY_LENINT(in_paramtypes);
 		paramTypes = ALLOC_N(Oid, nParams);
 		for(i = 0; i < nParams; i++) {
 			param = rb_ary_entry(in_paramtypes, i);
@@ -1490,8 +1531,10 @@ pgconn_sync_prepare(int argc, VALUE *argv, VALUE self)
 				paramTypes[i] = NUM2UINT(param);
 		}
 	}
-	result = gvl_PQprepare(this->pgconn, name_cstr, command_cstr, nParams, paramTypes);
+	result = PQprepare(this->pgconn, name_cstr, command_cstr, nParams, paramTypes);
 
+	RB_GC_GUARD(transcoded_str1);
+	RB_GC_GUARD(transcoded_str2);
 	xfree(paramTypes);
 
 	rb_pgresult = pg_new_result(result, self);
@@ -1515,6 +1558,7 @@ pgconn_sync_exec_prepared(int argc, VALUE *argv, VALUE self)
 	PGresult *result = NULL;
 	VALUE rb_pgresult;
 	VALUE name, in_res_fmt;
+	VALUE transcoded_str;
 	int nParams;
 	int resultFormat;
 	struct query_params_data paramsData = { this->enc_idx };
@@ -1530,10 +1574,11 @@ pgconn_sync_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(this->pgconn, pg_cstr_enc(name, paramsData.enc_idx), nParams,
+	result = PQexecPrepared(this->pgconn, pg_cstr_enc(name, paramsData.enc_idx, &transcoded_str), nParams,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats,
 		resultFormat);
 
+	RB_GC_GUARD(transcoded_str);
 	free_query_params( &paramsData );
 
 	rb_pgresult = pg_new_result(result, self);
@@ -1550,9 +1595,13 @@ pgconn_sync_describe_close_prepared_portal(VALUE self, VALUE name, PGresult *(*f
 {
 	PGresult *result;
 	VALUE rb_pgresult;
+	VALUE transcoded_str;
 	t_pg_connection *this = pg_get_connection_safe( self );
-	const char *stmt = NIL_P(name) ? NULL : pg_cstr_enc(name, this->enc_idx);
+	const char *stmt = NIL_P(name) ? NULL : pg_cstr_enc(name, this->enc_idx, &transcoded_str);
+
 	result = func(this->pgconn, stmt);
+
+	RB_GC_GUARD(transcoded_str);
 	rb_pgresult = pg_new_result(result, self);
 	pg_result_check(rb_pgresult);
 	return rb_pgresult;
@@ -1569,7 +1618,7 @@ pgconn_sync_describe_close_prepared_portal(VALUE self, VALUE name, PGresult *(*f
 static VALUE
 pgconn_sync_describe_prepared(VALUE self, VALUE stmt_name)
 {
-	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, gvl_PQdescribePrepared);
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQdescribePrepared);
 }
 
 
@@ -1584,11 +1633,11 @@ pgconn_sync_describe_prepared(VALUE self, VALUE stmt_name)
 static VALUE
 pgconn_sync_describe_portal(VALUE self, VALUE stmt_name)
 {
-	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, gvl_PQdescribePortal);
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQdescribePortal);
 }
 
 
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 /*
  * call-seq:
  *    conn.sync_close_prepared( stmt_name ) -> PG::Result
@@ -1602,7 +1651,7 @@ pgconn_sync_describe_portal(VALUE self, VALUE stmt_name)
 static VALUE
 pgconn_sync_close_prepared(VALUE self, VALUE stmt_name)
 {
-	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, gvl_PQclosePrepared);
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQclosePrepared);
 }
 
 /*
@@ -1618,7 +1667,7 @@ pgconn_sync_close_prepared(VALUE self, VALUE stmt_name)
 static VALUE
 pgconn_sync_close_portal(VALUE self, VALUE stmt_name)
 {
-	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, gvl_PQclosePortal);
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQclosePortal);
 }
 #endif
 
@@ -1892,7 +1941,7 @@ pgconn_set_single_row_mode(VALUE self)
 	return self;
 }
 
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 /*
  * call-seq:
  *    conn.set_chunked_rows_mode -> self
@@ -1949,13 +1998,15 @@ static VALUE pgconn_send_query_params(int argc, VALUE *argv, VALUE self);
 static VALUE
 pgconn_send_query(int argc, VALUE *argv, VALUE self)
 {
+	VALUE transcoded_str;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
 	/* If called with no or nil parameters, use PQexec for compatibility */
 	if ( argc == 1 || (argc >= 2 && argc <= 4 && NIL_P(argv[1]) )) {
-		if(gvl_PQsendQuery(this->pgconn, pg_cstr_enc(argv[0], this->enc_idx)) == 0)
+		if(PQsendQuery(this->pgconn, pg_cstr_enc(argv[0], this->enc_idx, &transcoded_str)) == 0)
 			pg_raise_conn_error( rb_eUnableToSend, self, "PQsendQuery %s", PQerrorMessage(this->pgconn));
 
+		RB_GC_GUARD(transcoded_str);
 		pgconn_wait_for_flush( self );
 		return Qnil;
 	}
@@ -2012,6 +2063,7 @@ pgconn_send_query_params(int argc, VALUE *argv, VALUE self)
 	t_pg_connection *this = pg_get_connection_safe( self );
 	int result;
 	VALUE command, in_res_fmt;
+	VALUE transcoded_str;
 	int nParams;
 	int resultFormat;
 	struct query_params_data paramsData = { this->enc_idx };
@@ -2023,9 +2075,10 @@ pgconn_send_query_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_PQsendQueryParams(this->pgconn, pg_cstr_enc(command, paramsData.enc_idx), nParams, paramsData.types,
+	result = PQsendQueryParams(this->pgconn, pg_cstr_enc(command, paramsData.enc_idx, &transcoded_str), nParams, paramsData.types,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats, resultFormat);
 
+	RB_GC_GUARD(transcoded_str);
 	free_query_params( &paramsData );
 
 	if(result == 0)
@@ -2062,6 +2115,7 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	int result;
 	VALUE name, command, in_paramtypes;
 	VALUE param;
+	VALUE transcoded_str1, transcoded_str2;
 	int i = 0;
 	int nParams = 0;
 	Oid *paramTypes = NULL;
@@ -2070,12 +2124,12 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 	int enc_idx = this->enc_idx;
 
 	rb_scan_args(argc, argv, "21", &name, &command, &in_paramtypes);
-	name_cstr = pg_cstr_enc(name, enc_idx);
-	command_cstr = pg_cstr_enc(command, enc_idx);
+	name_cstr = pg_cstr_enc(name, enc_idx, &transcoded_str1);
+	command_cstr = pg_cstr_enc(command, enc_idx, &transcoded_str2);
 
 	if(! NIL_P(in_paramtypes)) {
 		Check_Type(in_paramtypes, T_ARRAY);
-		nParams = (int)RARRAY_LEN(in_paramtypes);
+		nParams = RARRAY_LENINT(in_paramtypes);
 		paramTypes = ALLOC_N(Oid, nParams);
 		for(i = 0; i < nParams; i++) {
 			param = rb_ary_entry(in_paramtypes, i);
@@ -2085,8 +2139,10 @@ pgconn_send_prepare(int argc, VALUE *argv, VALUE self)
 				paramTypes[i] = NUM2UINT(param);
 		}
 	}
-	result = gvl_PQsendPrepare(this->pgconn, name_cstr, command_cstr, nParams, paramTypes);
+	result = PQsendPrepare(this->pgconn, name_cstr, command_cstr, nParams, paramTypes);
 
+	RB_GC_GUARD(transcoded_str1);
+	RB_GC_GUARD(transcoded_str2);
 	xfree(paramTypes);
 
 	if(result == 0) {
@@ -2134,6 +2190,7 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 	t_pg_connection *this = pg_get_connection_safe( self );
 	int result;
 	VALUE name, in_res_fmt;
+	VALUE transcoded_str;
 	int nParams;
 	int resultFormat;
 	struct query_params_data paramsData = { this->enc_idx };
@@ -2149,10 +2206,11 @@ 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(this->pgconn, pg_cstr_enc(name, paramsData.enc_idx), nParams,
+	result = PQsendQueryPrepared(this->pgconn, pg_cstr_enc(name, paramsData.enc_idx, &transcoded_str), nParams,
 		(const char * const *)paramsData.values, paramsData.lengths, paramsData.formats,
 		resultFormat);
 
+	RB_GC_GUARD(transcoded_str);
 	free_query_params( &paramsData );
 
 	if(result == 0)
@@ -2166,12 +2224,14 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 static VALUE
 pgconn_send_describe_close_prepared_portal(VALUE self, VALUE name, int (*func)(PGconn *, const char *), const char *funame)
 {
+	VALUE transcoded_str;
 	t_pg_connection *this = pg_get_connection_safe( self );
-	const char *stmt = NIL_P(name) ? NULL : pg_cstr_enc(name, this->enc_idx);
+	const char *stmt = NIL_P(name) ? NULL : pg_cstr_enc(name, this->enc_idx, &transcoded_str);
 	/* returns 0 on failure */
 	if(func(this->pgconn, stmt) == 0)
 		pg_raise_conn_error( rb_eUnableToSend, self, "%s %s", funame, PQerrorMessage(this->pgconn));
 
+	RB_GC_GUARD(transcoded_str);
 	pgconn_wait_for_flush( self );
 	return Qnil;
 }
@@ -2187,7 +2247,7 @@ static VALUE
 pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 {
 	return pgconn_send_describe_close_prepared_portal(
-		self, stmt_name, gvl_PQsendDescribePrepared,
+		self, stmt_name, PQsendDescribePrepared,
 		"PQsendDescribePrepared");
 }
 
@@ -2203,11 +2263,11 @@ static VALUE
 pgconn_send_describe_portal(VALUE self, VALUE portal)
 {
 	return pgconn_send_describe_close_prepared_portal(
-		self, portal, gvl_PQsendDescribePortal,
+		self, portal, PQsendDescribePortal,
 		"PQsendDescribePortal");
 }
 
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 /*
  * call-seq:
  *    conn.send_close_prepared( statement_name ) -> nil
@@ -2221,7 +2281,7 @@ static VALUE
 pgconn_send_close_prepared(VALUE self, VALUE stmt_name)
 {
 	return pgconn_send_describe_close_prepared_portal(
-		self, stmt_name, gvl_PQsendClosePrepared,
+		self, stmt_name, PQsendClosePrepared,
 		"PQsendClosePrepared");
 }
 
@@ -2239,7 +2299,7 @@ static VALUE
 pgconn_send_close_portal(VALUE self, VALUE portal)
 {
 	return pgconn_send_describe_close_prepared_portal(
-		self, portal, gvl_PQsendClosePortal,
+		self, portal, PQsendClosePortal,
 		"PQsendClosePortal");
 }
 #endif
@@ -2251,7 +2311,7 @@ pgconn_sync_get_result(VALUE self)
 	PGresult *result;
 	VALUE rb_pgresult;
 
-	result = gvl_PQgetResult(conn);
+	result = PQgetResult(conn);
 	if(result == NULL)
 		return Qnil;
 	rb_pgresult = pg_new_result(result, self);
@@ -2293,7 +2353,7 @@ pgconn_consume_input(VALUE self)
 static VALUE
 pgconn_is_busy(VALUE self)
 {
-	return gvl_PQisBusy(pg_get_pgconn(self)) ? Qtrue : Qfalse;
+	return PQisBusy(pg_get_pgconn(self)) ? Qtrue : Qfalse;
 }
 
 static VALUE
@@ -2333,7 +2393,7 @@ pgconn_sync_flush(VALUE self)
 	return (ret) ? Qfalse : Qtrue;
 }
 
-#ifndef HAVE_PQSETCHUNKEDROWSMODE
+#ifndef LIBPQ_HAS_CHUNK_MODE
 static VALUE
 pgconn_sync_cancel(VALUE self)
 {
@@ -2346,7 +2406,7 @@ pgconn_sync_cancel(VALUE self)
 	if(cancel == NULL)
 		pg_raise_conn_error( rb_ePGerror, self, "Invalid connection!");
 
-	ret = gvl_PQcancel(cancel, errbuf, sizeof(errbuf));
+	ret = PQcancel(cancel, errbuf, sizeof(errbuf));
 	if(ret == 1)
 		retval = Qnil;
 	else
@@ -2378,7 +2438,7 @@ pgconn_notifies(VALUE self)
 	sym_be_pid = ID2SYM(rb_intern("be_pid"));
 	sym_extra = ID2SYM(rb_intern("extra"));
 
-	notification = gvl_PQnotifies(this->pgconn);
+	notification = PQnotifies(this->pgconn);
 	if (notification == NULL) {
 		return Qnil;
 	}
@@ -2398,33 +2458,13 @@ pgconn_notifies(VALUE self)
 	return hash;
 }
 
-#ifndef HAVE_RB_IO_DESCRIPTOR
-static int
-rb_io_descriptor(VALUE io)
-{
-	rb_io_t *fptr;
-	Check_Type(io, T_FILE);
-	fptr = RFILE(io)->fptr;
-	rb_io_check_closed(fptr);
-	return fptr->fd;
-}
-#endif
-
 #if defined(_WIN32)
 
 /* We use a specialized implementation of rb_io_wait() on Windows.
  * This is because rb_io_wait() and rb_wait_for_single_fd() are very slow on Windows.
  */
 
-#if defined(HAVE_RUBY_FIBER_SCHEDULER_H)
 #include <ruby/fiber/scheduler.h>
-#endif
-
-typedef enum {
-    PG_RUBY_IO_READABLE = RB_WAITFD_IN,
-    PG_RUBY_IO_WRITABLE = RB_WAITFD_OUT,
-    PG_RUBY_IO_PRIORITY = RB_WAITFD_PRI,
-} pg_rb_io_event_t;
 
 int rb_w32_wait_events( HANDLE *events, int num, DWORD timeout );
 
@@ -2448,9 +2488,9 @@ pg_rb_thread_io_wait(VALUE io, VALUE events, VALUE timeout) {
 		timeradd(&currtime, &ptimeout, &aborttime);
 	}
 
-	if(rb_events & PG_RUBY_IO_READABLE) w32_events |= FD_READ | FD_ACCEPT | FD_CLOSE;
-	if(rb_events & PG_RUBY_IO_WRITABLE) w32_events |= FD_WRITE | FD_CONNECT;
-	if(rb_events & PG_RUBY_IO_PRIORITY) w32_events |= FD_OOB;
+	if(rb_events & RUBY_IO_READABLE) w32_events |= FD_READ | FD_ACCEPT | FD_CLOSE;
+	if(rb_events & RUBY_IO_WRITABLE) w32_events |= FD_WRITE | FD_CONNECT;
+	if(rb_events & RUBY_IO_PRIORITY) w32_events |= FD_OOB;
 
 	for(;;) {
 		if ( WSAEventSelect(_get_osfhandle(rb_io_descriptor(io)), hEvent, w32_events) == SOCKET_ERROR ) {
@@ -2494,49 +2534,20 @@ pg_rb_thread_io_wait(VALUE io, VALUE events, VALUE timeout) {
 
 static VALUE
 pg_rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
-#if defined(HAVE_RUBY_FIBER_SCHEDULER_H)
-	/* We don't support Fiber.scheduler on Windows ruby-3.0 because there is no fast way to check whether a scheduler is active.
-	 * Fortunately ruby-3.1 offers a C-API for it.
-	 */
+	/* Avoid slow rb_io_wait() on Windows, if no scheduler is active. */
 	VALUE scheduler = rb_fiber_scheduler_current();
 
 	if (!NIL_P(scheduler)) {
 		return rb_io_wait(io, events, timeout);
 	}
-#endif
 	return pg_rb_thread_io_wait(io, events, timeout);
 }
 
-#elif defined(HAVE_RB_IO_WAIT)
-
-/* Use our own function and constants names, to avoid conflicts with truffleruby-head on its road to ruby-3.0 compatibility. */
-#define pg_rb_io_wait rb_io_wait
-#define PG_RUBY_IO_READABLE RUBY_IO_READABLE
-#define PG_RUBY_IO_WRITABLE RUBY_IO_WRITABLE
-#define PG_RUBY_IO_PRIORITY RUBY_IO_PRIORITY
-
 #else
-/* For compat with ruby < 3.0 */
-
-typedef enum {
-    PG_RUBY_IO_READABLE = RB_WAITFD_IN,
-    PG_RUBY_IO_WRITABLE = RB_WAITFD_OUT,
-    PG_RUBY_IO_PRIORITY = RB_WAITFD_PRI,
-} pg_rb_io_event_t;
-
-static VALUE
-pg_rb_io_wait(VALUE io, VALUE events, VALUE timeout) {
-	struct timeval waittime;
-	int res;
 
-	if( !NIL_P(timeout) ){
-		waittime.tv_sec = (time_t)(NUM2DBL(timeout));
-		waittime.tv_usec = (time_t)((NUM2DBL(timeout) - (double)waittime.tv_sec) * 1e6);
-	}
-	res = rb_wait_for_single_fd(rb_io_descriptor(io), NUM2UINT(events), NIL_P(timeout) ? NULL : &waittime);
+/* Use rb_io_wait on non-Windows systems */
+#define pg_rb_io_wait rb_io_wait
 
-	return UINT2NUM(res);
-}
 #endif
 
 static void *
@@ -2571,7 +2582,7 @@ wait_socket_readable( VALUE self, struct timeval *ptimeout, void *(*is_readable)
 
 			socket_io = pgconn_socket_io(self);
 			/* Wait for the socket to become readable before checking again */
-			ret = pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), wait_timeout);
+			ret = pg_rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE), wait_timeout);
 		} else {
 			ret = Qfalse;
 		}
@@ -2608,9 +2619,9 @@ pgconn_async_flush(VALUE self)
 		/* wait for the socket to become read- or write-ready */
 		int events;
 		VALUE socket_io = pgconn_socket_io(self);
-		events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
+		events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE | RUBY_IO_WRITABLE), Qnil));
 
-		if (events & PG_RUBY_IO_READABLE){
+		if (events & RUBY_IO_READABLE){
 			pgconn_consume_input(self);
 		}
 	}
@@ -2636,7 +2647,7 @@ pgconn_flush_data_set( VALUE self, VALUE enabled ){
 static void *
 notify_readable(PGconn *conn)
 {
-	return (void*)gvl_PQnotifies(conn);
+	return (void*)PQnotifies(conn);
 }
 
 /*
@@ -2735,7 +2746,7 @@ pgconn_sync_put_copy_data(int argc, VALUE *argv, VALUE self)
 
 	Check_Type(buffer, T_STRING);
 
-	ret = gvl_PQputCopyData(this->pgconn, RSTRING_PTR(buffer), RSTRING_LENINT(buffer));
+	ret = PQputCopyData(this->pgconn, RSTRING_PTR(buffer), RSTRING_LENINT(buffer));
 	if(ret == -1)
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
 
@@ -2748,6 +2759,7 @@ static VALUE
 pgconn_sync_put_copy_end(int argc, VALUE *argv, VALUE self)
 {
 	VALUE str;
+	VALUE transcoded_str;
 	int ret;
 	const char *error_message = NULL;
 	t_pg_connection *this = pg_get_connection_safe( self );
@@ -2755,15 +2767,41 @@ pgconn_sync_put_copy_end(int argc, VALUE *argv, VALUE self)
 	if (rb_scan_args(argc, argv, "01", &str) == 0)
 		error_message = NULL;
 	else
-		error_message = pg_cstr_enc(str, this->enc_idx);
+		error_message = pg_cstr_enc(str, this->enc_idx, &transcoded_str);
 
-	ret = gvl_PQputCopyEnd(this->pgconn, error_message);
+	ret = PQputCopyEnd(this->pgconn, error_message);
 	if(ret == -1)
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
 
+	RB_GC_GUARD(transcoded_str);
 	return (ret) ? Qtrue : Qfalse;
 }
 
+struct pgconn_copy_data {
+	t_pg_coder *coder;
+	char *buffer;
+	int length;
+	int enc_idx;
+};
+
+static VALUE
+pgconn_decode_copy_data(VALUE data_ptr)
+{
+	struct pgconn_copy_data *data = (struct pgconn_copy_data *)data_ptr;
+	t_pg_coder_dec_func dec_func = pg_coder_dec_func(data->coder, data->coder->format);
+
+	return dec_func(data->coder, data->buffer, data->length, 0, 0, data->enc_idx);
+}
+
+static VALUE
+pgconn_free_copy_data(VALUE data_ptr)
+{
+	struct pgconn_copy_data *data = (struct pgconn_copy_data *)data_ptr;
+
+	PQfreemem(data->buffer);
+	return Qnil;
+}
+
 static VALUE
 pgconn_sync_get_copy_data(int argc, VALUE *argv, VALUE self )
 {
@@ -2786,7 +2824,7 @@ pgconn_sync_get_copy_data(int argc, VALUE *argv, VALUE self )
 		TypedData_Get_Struct(decoder, t_pg_coder, &pg_coder_type, p_coder);
 	}
 
-	ret = gvl_PQgetCopyData(this->pgconn, &buffer, RTEST(async_in));
+	ret = PQgetCopyData(this->pgconn, &buffer, RTEST(async_in));
 	if(ret == -2){ /* error */
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(this->pgconn));
 	}
@@ -2798,8 +2836,9 @@ pgconn_sync_get_copy_data(int argc, VALUE *argv, VALUE self )
 	}
 
 	if( p_coder ){
-		t_pg_coder_dec_func dec_func = pg_coder_dec_func( p_coder, p_coder->format );
-		result =  dec_func( p_coder, buffer, ret, 0, 0, this->enc_idx );
+		struct pgconn_copy_data data = { p_coder, buffer, ret, this->enc_idx };
+
+		return rb_ensure(pgconn_decode_copy_data, (VALUE)&data, pgconn_free_copy_data, (VALUE)&data);
 	} else {
 		result = rb_str_new(buffer, ret);
 	}
@@ -2932,11 +2971,10 @@ pgconn_untrace(VALUE self)
 void
 notice_receiver_proxy(void *arg, const PGresult *pgresult)
 {
-	VALUE self = (VALUE)arg;
-	t_pg_connection *this = pg_get_connection( self );
+	t_pg_connection *this = (t_pg_connection*)arg;
 
 	if (this->notice_receiver != Qnil) {
-		VALUE result = pg_new_result_autoclear( (PGresult *)pgresult, self );
+		VALUE result = pg_new_result_autoclear( (PGresult *)pgresult, this->self );
 
 		rb_funcall(this->notice_receiver, rb_intern("call"), 1, result);
 		pg_result_clear( result );
@@ -2991,7 +3029,7 @@ pgconn_set_notice_receiver(VALUE self)
 	old_proc = this->notice_receiver;
 	if( rb_block_given_p() ) {
 		proc = rb_block_proc();
-		PQsetNoticeReceiver(this->pgconn, gvl_notice_receiver_proxy, (void *)self);
+		PQsetNoticeReceiver(this->pgconn, gvl_notice_receiver_proxy, (void *)this);
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
@@ -3010,8 +3048,7 @@ pgconn_set_notice_receiver(VALUE self)
 void
 notice_processor_proxy(void *arg, const char *message)
 {
-	VALUE self = (VALUE)arg;
-	t_pg_connection *this = pg_get_connection( self );
+	t_pg_connection *this = (t_pg_connection*)arg;
 
 	if (this->notice_processor != Qnil) {
 		VALUE message_str = rb_str_new2(message);
@@ -3052,7 +3089,7 @@ pgconn_set_notice_processor(VALUE self)
 	old_proc = this->notice_processor;
 	if( rb_block_given_p() ) {
 		proc = rb_block_proc();
-		PQsetNoticeProcessor(this->pgconn, gvl_notice_processor_proxy, (void *)self);
+		PQsetNoticeProcessor(this->pgconn, gvl_notice_processor_proxy, (void *)this);
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
@@ -3094,7 +3131,7 @@ pgconn_sync_set_client_encoding(VALUE self, VALUE str)
 	rb_check_frozen(self);
 	Check_Type(str, T_STRING);
 
-	if ( (gvl_PQsetClientEncoding(conn, StringValueCStr(str))) == -1 )
+	if ( (PQsetClientEncoding(conn, StringValueCStr(str))) == -1 )
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 
 	pgconn_set_internal_encoding_index( self );
@@ -3159,7 +3196,7 @@ pgconn_s_quote_ident(VALUE self, VALUE str_or_array)
 static void *
 get_result_readable(PGconn *conn)
 {
-	return gvl_PQisBusy(conn) ? NULL : (void*)1;
+	return PQisBusy(conn) ? NULL : (void*)1;
 }
 
 
@@ -3217,7 +3254,7 @@ pgconn_sync_get_last_result(VALUE self)
 
 
 	cur = prev = NULL;
-	while ((cur = gvl_PQgetResult(conn)) != NULL) {
+	while ((cur = PQgetResult(conn)) != NULL) {
 		int status;
 
 		if (prev) PQclear(prev);
@@ -3269,7 +3306,7 @@ pgconn_async_get_last_result(VALUE self)
 		 */
 		wait_socket_readable(self, NULL, get_result_readable);
 
-		cur = gvl_PQgetResult(conn);
+		cur = PQgetResult(conn);
 		if (cur == NULL)
 			break;
 
@@ -3326,18 +3363,18 @@ pgconn_discard_results(VALUE self)
 		/* pgconn_block() raises an exception in case of errors.
 		* To avoid this call pg_rb_io_wait() and PQconsumeInput() without rb_raise().
 		*/
-		while( gvl_PQisBusy(conn) ){
+		while( PQisBusy(conn) ){
 			int events;
 
 			switch( PQflush(conn) ) {
 				case 1:
-					events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
-					if (events & PG_RUBY_IO_READABLE){
+					events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE | RUBY_IO_WRITABLE), Qnil));
+					if (events & RUBY_IO_READABLE){
 						if ( PQconsumeInput(conn) == 0 ) goto error;
 					}
 					break;
 				case 0:
-					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
+					pg_rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
 					if ( PQconsumeInput(conn) == 0 ) goto error;
 					break;
 				default:
@@ -3345,23 +3382,23 @@ pgconn_discard_results(VALUE self)
 			}
 		}
 
-		cur = gvl_PQgetResult(conn);
+		cur = PQgetResult(conn);
 		if( cur == NULL) break;
 
 		status = PQresultStatus(cur);
 		PQclear(cur);
 		if (status == PGRES_COPY_IN){
-			while( gvl_PQputCopyEnd(conn, "COPY terminated by new query or discard_results") == 0 ){
+			while( PQputCopyEnd(conn, "COPY terminated by new query or discard_results") == 0 ){
 				pgconn_async_flush(self);
 			}
 		}
 		if (status == PGRES_COPY_OUT){
 			for(;;) {
 				char *buffer = NULL;
-				int st = gvl_PQgetCopyData(conn, &buffer, 1);
+				int st = PQgetCopyData(conn, &buffer, 1);
 				if( st == 0 ) {
 					/* would block -> wait for readable data */
-					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
+					pg_rb_io_wait(socket_io, RB_INT2NUM(RUBY_IO_READABLE), Qnil);
 					if ( PQconsumeInput(conn) == 0 ) goto error;
 				} else if( st > 0 ) {
 					/* some data retrieved -> discard it */
@@ -3398,12 +3435,12 @@ error:
  * 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 an alias for #async_exec which is almost identical to #sync_exec .
+ * #exec is an alias for #async_exec which is functional identical to #sync_exec .
  * #sync_exec is implemented on the simpler synchronous command processing API of libpq, whereas
  * #async_exec is implemented on the asynchronous API and on ruby's IO mechanisms.
  * Only #async_exec is compatible to <tt>Fiber.scheduler</tt> based asynchronous IO processing introduced in ruby-3.0.
- * Both methods ensure that other threads can process while waiting for the server to
- * complete the request, but #sync_exec blocks all signals to be processed until the query is finished.
+ * Only #async_exec ensures that other threads can process while waiting for the server to complete the request.
+ * In contrast #sync_exec blocks all threads and signals to be processed until the query is finished.
  * This is most notably visible by a delayed reaction to Control+C.
  * It's not recommended to use explicit sync or async variants but #exec instead, unless you have a good reason to do so.
  *
@@ -3438,12 +3475,13 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
  * +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   => Integer (oid of type of bind parameter)
- *      :format => Integer (0 for text, 1 for binary)
+ *     {:value    => String (value of bind parameter)
+ *      :type     => Integer (oid of type of bind parameter)
+ *      :typename => String (name of type of bind parameter, only used for conn.embed_params )
+ *      :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 }
+ *     { :value   => <string value>, :type => 0, :format => 0 }
  *
  * PostgreSQL bind parameters are represented as $1, $2, $3, etc.,
  * inside the SQL query. The 0th element of the +params+ array is bound
@@ -3632,7 +3670,7 @@ pgconn_async_describe_prepared(VALUE self, VALUE stmt_name)
 	return pgconn_async_describe_close_prepared_potral(self, stmt_name, pgconn_send_describe_prepared);
 }
 
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 /*
  * call-seq:
  *    conn.close_prepared( statement_name ) -> PG::Result
@@ -3754,7 +3792,7 @@ pgconn_ssl_attribute_names(VALUE self)
 
 
 
-#ifdef HAVE_PQENTERPIPELINEMODE
+#ifdef LIBPQ_HAS_PIPELINING
 /*
  * call-seq:
  *    conn.pipeline_status -> Integer
@@ -3839,7 +3877,7 @@ static VALUE
 pgconn_sync_pipeline_sync(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
-	int res = gvl_PQpipelineSync(conn);
+	int res = PQpipelineSync(conn);
 	if( res != 1 )
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 
@@ -3847,7 +3885,7 @@ pgconn_sync_pipeline_sync(VALUE self)
 }
 
 
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 /*
  * call-seq:
  *    conn.send_pipeline_sync -> nil
@@ -3864,7 +3902,7 @@ static VALUE
 pgconn_send_pipeline_sync(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
-	int res = gvl_PQsendPipelineSync(conn);
+	int res = PQsendPipelineSync(conn);
 	if( res != 1 )
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 
@@ -4305,7 +4343,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 ( gvl_PQsetClientEncoding(pg_get_pgconn( self ), name) == -1 ) {
+		if ( 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 );
@@ -4345,12 +4383,12 @@ pgconn_external_encoding(VALUE self)
 static VALUE
 pgconn_async_set_client_encoding(VALUE self, VALUE encname)
 {
-	VALUE query_format, query;
+	VALUE query;
 
 	rb_check_frozen(self);
 	Check_Type(encname, T_STRING);
-	query_format = rb_str_new_cstr("set client_encoding to '%s'");
-	query = rb_funcall(query_format, rb_intern("%"), 1, encname);
+	query = rb_str_new_cstr("set client_encoding to ");
+	rb_str_concat(query, pgconn_escape_literal(self, encname));
 
 	pgconn_async_exec(1, &query, self);
 	pgconn_set_internal_encoding_index( self );
@@ -4642,7 +4680,6 @@ pgconn_field_name_type_set(VALUE self, VALUE sym)
 	rb_check_frozen(self);
 	this->flags &= ~PG_RESULT_FIELD_NAMES_MASK;
 	if( sym == sym_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_SYMBOL;
-	else if ( sym == sym_static_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_STATIC_SYMBOL;
 	else if ( sym == sym_string );
 	else rb_raise(rb_eArgError, "invalid argument %+"PRIsVALUE, sym);
 
@@ -4664,8 +4701,6 @@ pgconn_field_name_type_get(VALUE self)
 
 	if( this->flags & PG_RESULT_FIELD_NAMES_SYMBOL ){
 		return sym_symbol;
-	} else if( this->flags & PG_RESULT_FIELD_NAMES_STATIC_SYMBOL ){
-		return sym_static_symbol;
 	} else {
 		return sym_string;
 	}
@@ -4685,7 +4720,6 @@ init_pg_connection(void)
 	sym_value = ID2SYM(rb_intern("value"));
 	sym_string = ID2SYM(rb_intern("string"));
 	sym_symbol = ID2SYM(rb_intern("symbol"));
-	sym_static_symbol = ID2SYM(rb_intern("static_symbol"));
 
 	rb_cPGconn = rb_define_class_under( rb_mPG, "Connection", rb_cObject );
 	/* Help rdoc to known the Constants module */
@@ -4733,12 +4767,15 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "transaction_status", pgconn_transaction_status, 0);
 	rb_define_method(rb_cPGconn, "parameter_status", pgconn_parameter_status, 1);
 	rb_define_method(rb_cPGconn, "protocol_version", pgconn_protocol_version, 0);
+#ifdef LIBPQ_HAS_FULL_PROTOCOL_VERSION
+	rb_define_method(rb_cPGconn, "full_protocol_version", pgconn_full_protocol_version, 0);
+#endif
 	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);
 	rb_define_method(rb_cPGconn, "socket_io", pgconn_socket_io, 0);
 	rb_define_method(rb_cPGconn, "backend_pid", pgconn_backend_pid, 0);
-#ifndef HAVE_PQSETCHUNKEDROWSMODE
+#ifndef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "backend_key", pgconn_backend_key, 0);
 #endif
 	rb_define_method(rb_cPGconn, "connection_needs_password", pgconn_connection_needs_password, 0);
@@ -4752,7 +4789,7 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "sync_exec_prepared", pgconn_sync_exec_prepared, -1);
 	rb_define_method(rb_cPGconn, "sync_describe_prepared", pgconn_sync_describe_prepared, 1);
 	rb_define_method(rb_cPGconn, "sync_describe_portal", pgconn_sync_describe_portal, 1);
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "sync_close_prepared", pgconn_sync_close_prepared, 1);
 	rb_define_method(rb_cPGconn, "sync_close_portal", pgconn_sync_close_portal, 1);
 #endif
@@ -4763,7 +4800,7 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "exec_prepared", pgconn_async_exec_prepared, -1);
 	rb_define_method(rb_cPGconn, "describe_prepared", pgconn_async_describe_prepared, 1);
 	rb_define_method(rb_cPGconn, "describe_portal", pgconn_async_describe_portal, 1);
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "close_prepared", pgconn_async_close_prepared, 1);
 	rb_define_method(rb_cPGconn, "close_portal", pgconn_async_close_portal, 1);
 #endif
@@ -4775,7 +4812,7 @@ init_pg_connection(void)
 	rb_define_alias(rb_cPGconn, "async_exec_prepared", "exec_prepared");
 	rb_define_alias(rb_cPGconn, "async_describe_prepared", "describe_prepared");
 	rb_define_alias(rb_cPGconn, "async_describe_portal", "describe_portal");
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 	rb_define_alias(rb_cPGconn, "async_close_prepared", "close_prepared");
 	rb_define_alias(rb_cPGconn, "async_close_portal", "close_portal");
 #endif
@@ -4788,7 +4825,7 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
 	rb_define_method(rb_cPGconn, "unescape_bytea", pgconn_s_unescape_bytea, 1);
 	rb_define_method(rb_cPGconn, "set_single_row_mode", pgconn_set_single_row_mode, 0);
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "set_chunked_rows_mode", pgconn_set_chunked_rows_mode, 1);
 #endif
 
@@ -4810,7 +4847,7 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "discard_results", pgconn_discard_results, 0);
 
 	/******     PG::Connection INSTANCE METHODS: Cancelling Queries in Progress     ******/
-#ifndef HAVE_PQSETCHUNKEDROWSMODE
+#ifndef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "sync_cancel", pgconn_sync_cancel, 0);
 #endif
 
@@ -4852,13 +4889,13 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "ssl_attribute", pgconn_ssl_attribute, 1);
 	rb_define_method(rb_cPGconn, "ssl_attribute_names", pgconn_ssl_attribute_names, 0);
 
-#ifdef HAVE_PQENTERPIPELINEMODE
+#ifdef LIBPQ_HAS_PIPELINING
 	rb_define_method(rb_cPGconn, "pipeline_status", pgconn_pipeline_status, 0);
 	rb_define_method(rb_cPGconn, "enter_pipeline_mode", pgconn_enter_pipeline_mode, 0);
 	rb_define_method(rb_cPGconn, "exit_pipeline_mode", pgconn_exit_pipeline_mode, 0);
 	rb_define_method(rb_cPGconn, "sync_pipeline_sync", pgconn_sync_pipeline_sync, 0);
 	rb_define_method(rb_cPGconn, "send_flush_request", pgconn_send_flush_request, 0);
-#ifdef HAVE_PQSETCHUNKEDROWSMODE
+#ifdef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "send_pipeline_sync", pgconn_send_pipeline_sync, 0);
 #endif
 #endif