pg 1.5.9 → 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 );
@@ -30,11 +30,8 @@ static VALUE pgconn_async_flush(VALUE self);
 /*
  * Convenience function to raise connection errors
  */
-#ifdef __GNUC__
-__attribute__((format(printf, 3, 4)))
-#endif
-NORETURN( static void
-pg_raise_conn_error( VALUE klass, VALUE self, const char *format, ...))
+void
+pg_raise_conn_error( VALUE klass, VALUE self, const char *format, ...)
 {
 	VALUE msg, error;
 	va_list ap;
@@ -69,6 +66,7 @@ pg_get_connection_safe( VALUE self )
 	t_pg_connection *this;
 	TypedData_Get_Struct( self, t_pg_connection, &pg_connection_type, this);
 
+	rb_check_frozen(self);
 	if ( !this->pgconn )
 		pg_raise_conn_error( rb_eConnectionBad, self, "connection is closed");
 
@@ -96,6 +94,20 @@ pg_get_pgconn( VALUE self )
 }
 
 
+void
+pg_unwrap_socket_io( VALUE self, VALUE *p_socket_io, int ruby_sd )
+{
+	if ( RTEST(*p_socket_io) ) {
+#if defined(_WIN32)
+		if( rb_w32_unwrap_io_handle(ruby_sd) )
+			pg_raise_conn_error( rb_eConnectionBad, self, "Could not unwrap win32 socket handle");
+#endif
+		rb_funcall( *p_socket_io, rb_intern("close"), 0 );
+	}
+
+	RB_OBJ_WRITE(self, p_socket_io, Qnil);
+}
+
 
 /*
  * Close the associated socket IO object if there is one.
@@ -104,17 +116,7 @@ static void
 pgconn_close_socket_io( VALUE self )
 {
 	t_pg_connection *this = pg_get_connection( self );
-	VALUE socket_io = this->socket_io;
-
-	if ( RTEST(socket_io) ) {
-#if defined(_WIN32)
-		if( rb_w32_unwrap_io_handle(this->ruby_sd) )
-			pg_raise_conn_error( rb_eConnectionBad, self, "Could not unwrap win32 socket handle");
-#endif
-		rb_funcall( socket_io, rb_intern("close"), 0 );
-	}
-
-	RB_OBJ_WRITE(self, &this->socket_io, Qnil);
+	pg_unwrap_socket_io( self, &this->socket_io, this->ruby_sd);
 }
 
 
@@ -151,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);
 	}
 }
 
@@ -186,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 );
@@ -230,7 +233,7 @@ static const rb_data_type_t pg_connection_type = {
 		pgconn_gc_mark,
 		pgconn_gc_free,
 		pgconn_memsize,
-		pg_compact_callback(pgconn_gc_compact),
+		pgconn_gc_compact,
 	},
 	0,
 	0,
@@ -258,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);
@@ -278,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");
@@ -327,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");
@@ -348,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);
 }
@@ -419,7 +426,6 @@ pgconn_s_conninfo_parse(VALUE self, VALUE conninfo)
 }
 
 
-#ifdef HAVE_PQENCRYPTPASSWORDCONN
 static VALUE
 pgconn_sync_encrypt_password(int argc, VALUE *argv, VALUE self)
 {
@@ -433,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 );
@@ -443,7 +449,6 @@ pgconn_sync_encrypt_password(int argc, VALUE *argv, VALUE self)
 
 	return rval;
 }
-#endif
 
 
 /*
@@ -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");
@@ -609,7 +618,7 @@ pgconn_reset_start(VALUE self)
  *    conn.reset_poll -> Integer
  *
  * Checks the status of a connection reset operation.
- * See #connect_start and #connect_poll for
+ * See Connection.connect_start and #connect_poll for
  * usage information and return values.
  */
 static VALUE
@@ -760,7 +769,6 @@ pgconn_options(VALUE self)
  *
  * Returns the connection options used by a live connection.
  *
- * Available since PostgreSQL-9.3
  */
 static VALUE
 pgconn_conninfo( VALUE self )
@@ -847,31 +855,79 @@ pgconn_parameter_status(VALUE self, VALUE param_name)
  * call-seq:
  *   conn.protocol_version -> Integer
  *
- * The 3.0 protocol will normally be used when communicating with PostgreSQL 7.4
- * or later servers; pre-7.4 servers support only protocol 2.0. (Protocol 1.0 is
- * obsolete and not supported by libpq.)
+ * Interrogates the frontend/backend protocol being used.
+ *
+ * Applications might wish to use this function to determine whether certain features are supported.
+ * Currently, the only value is 3 (3.0 protocol).
+ * 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.
  */
 static VALUE
 pgconn_protocol_version(VALUE self)
 {
-	return INT2NUM(PQprotocolVersion(pg_get_pgconn(self)));
+	int protocol_version = PQprotocolVersion(pg_get_pgconn(self));
+	if (protocol_version == 0) {
+		pg_raise_conn_error( rb_eConnectionBad, self, "PQprotocolVersion() can't get protocol version");
+	}
+	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
  *
- * The number is formed by converting the major, minor, and revision
- * numbers into two-decimal-digit numbers and appending them together.
- * For example, version 7.4.2 will be returned as 70402, and version
- * 8.1 will be returned as 80100 (leading zeroes are not shown). Zero
- * is returned if the connection is bad.
+ * Returns an integer representing the server version.
+ *
+ * Applications might use this function to determine the version of the database server they are connected to.
+ * The result is formed by multiplying the server's major version number by 10000 and adding the minor version number.
+ * For example, version 10.1 will be returned as 100001, and version 11.0 will be returned as 110000.
+ *
+ * PG::ConnectionBad is raised if the connection is bad.
+ *
+ * Prior to major version 10, PostgreSQL used three-part version numbers in which the first two parts together represented the major version.
+ * For those versions, PQserverVersion uses two digits for each part; for example version 9.1.5 will be returned as 90105, and version 9.2.0 will be returned as 90200.
+ *
+ * Therefore, for purposes of determining feature compatibility, applications should divide the result of PQserverVersion by 100 not 10000 to determine a logical major version number.
+ * In all release series, only the last two digits differ between minor releases (bug-fix releases).
  *
  */
 static VALUE
 pgconn_server_version(VALUE self)
 {
-	return INT2NUM(PQserverVersion(pg_get_pgconn(self)));
+	int server_version = PQserverVersion(pg_get_pgconn(self));
+	if (server_version == 0) {
+		pg_raise_conn_error( rb_eConnectionBad, self, "PQserverVersion() can't get server version");
+	}
+	return INT2NUM(server_version);
 }
 
 /*
@@ -920,13 +976,42 @@ pgconn_socket(VALUE self)
 	return INT2NUM(sd);
 }
 
+
+VALUE
+pg_wrap_socket_io(int sd, VALUE self, VALUE *p_socket_io, int *p_ruby_sd)
+{
+	int ruby_sd;
+	VALUE cSocket;
+	VALUE socket_io = *p_socket_io;
+
+	#ifdef _WIN32
+		ruby_sd = rb_w32_wrap_io_handle((HANDLE)(intptr_t)sd, O_RDWR|O_BINARY|O_NOINHERIT);
+		if( ruby_sd == -1 )
+			pg_raise_conn_error( rb_eConnectionBad, self, "Could not wrap win32 socket handle");
+
+		*p_ruby_sd = ruby_sd;
+	#else
+		*p_ruby_sd = ruby_sd = sd;
+	#endif
+
+	cSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
+	socket_io = rb_funcall( cSocket, rb_intern("for_fd"), 1, INT2NUM(ruby_sd));
+
+	/* Disable autoclose feature */
+	rb_funcall( socket_io, s_id_autoclose_set, 1, Qfalse );
+
+	RB_OBJ_WRITE(self, p_socket_io, socket_io);
+
+	return socket_io;
+}
+
 /*
  * call-seq:
  *    conn.socket_io() -> IO
  *
  * Fetch an IO object created from the Connection's underlying socket.
  * This object can be used per <tt>socket_io.wait_readable</tt>, <tt>socket_io.wait_writable</tt> or for <tt>IO.select</tt> to wait for events while running asynchronous API calls.
- * <tt>IO#wait_*able</tt> is is <tt>Fiber.scheduler</tt> compatible in contrast to <tt>IO.select</tt>.
+ * <tt>IO#wait_*able</tt> is <tt>Fiber.scheduler</tt> compatible in contrast to <tt>IO.select</tt>.
  *
  * The IO object can change while the connection is established, but is memorized afterwards.
  * So be sure not to cache the IO object, but repeat calling <tt>conn.socket_io</tt> instead.
@@ -937,37 +1022,17 @@ pgconn_socket(VALUE self)
 static VALUE
 pgconn_socket_io(VALUE self)
 {
-	int sd;
-	int ruby_sd;
 	t_pg_connection *this = pg_get_connection_safe( self );
-	VALUE cSocket;
-	VALUE socket_io = this->socket_io;
 
-	if ( !RTEST(socket_io) ) {
+	if ( !RTEST(this->socket_io) ) {
+		int sd;
 		if( (sd = PQsocket(this->pgconn)) < 0){
 			pg_raise_conn_error( rb_eConnectionBad, self, "PQsocket() can't get socket descriptor");
 		}
-
-		#ifdef _WIN32
-			ruby_sd = rb_w32_wrap_io_handle((HANDLE)(intptr_t)sd, O_RDWR|O_BINARY|O_NOINHERIT);
-			if( ruby_sd == -1 )
-				pg_raise_conn_error( rb_eConnectionBad, self, "Could not wrap win32 socket handle");
-
-			this->ruby_sd = ruby_sd;
-		#else
-			ruby_sd = sd;
-		#endif
-
-		cSocket = rb_const_get(rb_cObject, rb_intern("BasicSocket"));
-		socket_io = rb_funcall( cSocket, rb_intern("for_fd"), 1, INT2NUM(ruby_sd));
-
-		/* Disable autoclose feature */
-		rb_funcall( socket_io, s_id_autoclose_set, 1, Qfalse );
-
-		RB_OBJ_WRITE(self, &this->socket_io, socket_io);
+		return pg_wrap_socket_io( sd, self, &this->socket_io, &this->ruby_sd);
 	}
 
-	return socket_io;
+	return this->socket_io;
 }
 
 /*
@@ -984,6 +1049,7 @@ pgconn_backend_pid(VALUE self)
 	return INT2NUM(PQbackendPID(pg_get_pgconn(self)));
 }
 
+#ifndef LIBPQ_HAS_CHUNK_MODE
 typedef struct
 {
 	struct sockaddr_storage addr;
@@ -1028,6 +1094,7 @@ pgconn_backend_key(VALUE self)
 
 	return INT2NUM(be_key);
 }
+#endif
 
 /*
  * call-seq:
@@ -1069,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
@@ -1086,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()) {
@@ -1225,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);
@@ -1237,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 *) +
@@ -1300,7 +1369,7 @@ alloc_query_params(struct query_params_data *paramsData)
 				paramsData->lengths[i] = 0;
 			} else {
 				t_pg_coder_enc_func enc_func = pg_coder_enc_func( conv );
-				VALUE intermediate;
+				VALUE intermediate = Qnil;
 
 				/* 1st pass for retiving the required memory space */
 				int len = enc_func(conv, param_value, NULL, &intermediate, paramsData->enc_idx);
@@ -1340,8 +1409,6 @@ alloc_query_params(struct query_params_data *paramsData)
 						required_pool_size += len;
 					}
 				}
-
-				RB_GC_GUARD(intermediate);
 			}
 		}
 	}
@@ -1386,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 };
@@ -1407,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);
@@ -1438,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;
@@ -1446,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);
@@ -1461,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);
@@ -1486,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 };
@@ -1501,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);
@@ -1516,6 +1590,23 @@ pgconn_sync_exec_prepared(int argc, VALUE *argv, VALUE self)
 	return rb_pgresult;
 }
 
+static VALUE
+pgconn_sync_describe_close_prepared_portal(VALUE self, VALUE name, PGresult *(*func)(PGconn *, const char *))
+{
+	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, &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;
+}
+
 /*
  * call-seq:
  *    conn.sync_describe_prepared( statement_name ) -> PG::Result
@@ -1527,20 +1618,7 @@ pgconn_sync_exec_prepared(int argc, VALUE *argv, VALUE self)
 static VALUE
 pgconn_sync_describe_prepared(VALUE self, VALUE stmt_name)
 {
-	PGresult *result;
-	VALUE rb_pgresult;
-	t_pg_connection *this = pg_get_connection_safe( self );
-	const char *stmt;
-	if(NIL_P(stmt_name)) {
-		stmt = NULL;
-	}
-	else {
-		stmt = pg_cstr_enc(stmt_name, this->enc_idx);
-	}
-	result = gvl_PQdescribePrepared(this->pgconn, stmt);
-	rb_pgresult = pg_new_result(result, self);
-	pg_result_check(rb_pgresult);
-	return rb_pgresult;
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQdescribePrepared);
 }
 
 
@@ -1555,22 +1633,43 @@ pgconn_sync_describe_prepared(VALUE self, VALUE stmt_name)
 static VALUE
 pgconn_sync_describe_portal(VALUE self, VALUE stmt_name)
 {
-	PGresult *result;
-	VALUE rb_pgresult;
-	t_pg_connection *this = pg_get_connection_safe( self );
-	const char *stmt;
-	if(NIL_P(stmt_name)) {
-		stmt = NULL;
-	}
-	else {
-		stmt = pg_cstr_enc(stmt_name, this->enc_idx);
-	}
-	result = gvl_PQdescribePortal(this->pgconn, stmt);
-	rb_pgresult = pg_new_result(result, self);
-	pg_result_check(rb_pgresult);
-	return rb_pgresult;
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQdescribePortal);
+}
+
+
+#ifdef LIBPQ_HAS_CHUNK_MODE
+/*
+ * call-seq:
+ *    conn.sync_close_prepared( stmt_name ) -> PG::Result
+ *
+ * This function has the same behavior as #async_close_prepared, but is implemented using the synchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ * It's not recommended to use explicit sync or async variants but #close_prepared instead, unless you have a good reason to do so.
+ *
+ * Available since PostgreSQL-17.
+ */
+static VALUE
+pgconn_sync_close_prepared(VALUE self, VALUE stmt_name)
+{
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQclosePrepared);
 }
 
+/*
+ * call-seq:
+ *    conn.sync_close_portal( portal_name ) -> PG::Result
+ *
+ * This function has the same behavior as #async_close_portal, but is implemented using the synchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ * It's not recommended to use explicit sync or async variants but #close_portal instead, unless you have a good reason to do so.
+ *
+ * Available since PostgreSQL-17.
+ */
+static VALUE
+pgconn_sync_close_portal(VALUE self, VALUE stmt_name)
+{
+	return pgconn_sync_describe_close_prepared_portal(self, stmt_name, PQclosePortal);
+}
+#endif
 
 /*
  * call-seq:
@@ -1588,6 +1687,7 @@ pgconn_sync_describe_portal(VALUE self, VALUE stmt_name)
  * * +PGRES_FATAL_ERROR+
  * * +PGRES_COPY_BOTH+
  * * +PGRES_SINGLE_TUPLE+
+ * * +PGRES_TUPLES_CHUNK+
  * * +PGRES_PIPELINE_SYNC+
  * * +PGRES_PIPELINE_ABORTED+
  */
@@ -1812,14 +1912,11 @@ pgconn_escape_identifier(VALUE self, VALUE string)
  * (column names, types, etc) that an ordinary Result object for the query
  * would have.
  *
- * *Caution:* While processing a query, the server may return some rows and
- * then encounter an error, causing the query to be aborted. Ordinarily, pg
- * discards any such rows and reports only the error. But in single-row mode,
- * those rows will have already been returned to the application. Hence, the
- * application will see some Result objects followed by an Error raised in get_result.
- * For proper transactional behavior, the application must be designed to discard
- * or undo whatever has been done with the previously-processed rows, if the query
- * ultimately fails.
+ * *Caution:* While processing a query, the server may return some rows and then encounter an error, causing the query to be aborted.
+ * Ordinarily, pg discards any such rows and reports only the error.
+ * But in single-row or chunked mode, some rows may have already been returned to the application.
+ * Hence, the application will see some PGRES_SINGLE_TUPLE or PGRES_TUPLES_CHUNK PG::Result objects followed by a PG::Error raised in get_result.
+ * For proper transactional behavior, the application must be designed to discard or undo whatever has been done with the previously-processed rows, if the query ultimately fails.
  *
  * Example:
  *   conn.send_query( "your SQL command" )
@@ -1839,10 +1936,49 @@ pgconn_set_single_row_mode(VALUE self)
 
 	rb_check_frozen(self);
 	if( PQsetSingleRowMode(conn) == 0 )
-		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+		pg_raise_conn_error( rb_ePGerror, self, "PQsetSingleRowMode %s", PQerrorMessage(conn));
+
+	return self;
+}
+
+#ifdef LIBPQ_HAS_CHUNK_MODE
+/*
+ * call-seq:
+ *    conn.set_chunked_rows_mode -> self
+ *
+ * Select chunked mode for the currently-executing query.
+ *
+ * This function is similar to set_single_row_mode, except that it specifies retrieval of up to +chunk_size+ rows per PGresult, not necessarily just one row.
+ * This function can only be called immediately after send_query or one of its sibling functions, before any other operation on the connection such as consume_input or get_result.
+ * If called at the correct time, the function activates chunked mode for the current query.
+ * Otherwise the mode stays unchanged and the function raises an error.
+ * In any case, the mode reverts to normal after completion of the current query.
+ *
+ * Example:
+ *   conn.send_query( "your SQL command" )
+ *   conn.set_chunked_rows_mode(10)
+ *   loop do
+ *     res = conn.get_result or break
+ *     res.check
+ *     res.each do |row|
+ *       # do something with the received max. 10 rows
+ *     end
+ *   end
+ *
+ * Available since PostgreSQL-17
+ */
+static VALUE
+pgconn_set_chunked_rows_mode(VALUE self, VALUE chunk_size)
+{
+	PGconn *conn = pg_get_pgconn(self);
+
+	rb_check_frozen(self);
+	if( PQsetChunkedRowsMode(conn, NUM2INT(chunk_size)) == 0 )
+		pg_raise_conn_error( rb_ePGerror, self, "PQsetChunkedRowsMode %s", PQerrorMessage(conn));
 
 	return self;
 }
+#endif
 
 static VALUE pgconn_send_query_params(int argc, VALUE *argv, VALUE self);
 
@@ -1862,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)
-			pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+		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;
 	}
@@ -1925,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 };
@@ -1936,13 +2075,14 @@ 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)
-		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+		pg_raise_conn_error( rb_eUnableToSend, self, "PQsendQueryParams %s", PQerrorMessage(this->pgconn));
 
 	pgconn_wait_for_flush( self );
 	return Qnil;
@@ -1975,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;
@@ -1983,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);
@@ -1998,12 +2139,14 @@ 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) {
-		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+		pg_raise_conn_error( rb_eUnableToSend, self, "PQsendPrepare %s", PQerrorMessage(this->pgconn));
 	}
 	pgconn_wait_for_flush( self );
 	return Qnil;
@@ -2047,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 };
@@ -2062,15 +2206,32 @@ 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)
-		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+		pg_raise_conn_error( rb_eUnableToSend, self, "PQsendQueryPrepared %s", PQerrorMessage(this->pgconn));
+
+	pgconn_wait_for_flush( self );
+	return Qnil;
+}
+
+
+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, &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;
 }
@@ -2085,13 +2246,9 @@ pgconn_send_query_prepared(int argc, VALUE *argv, VALUE self)
 static VALUE
 pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 {
-	t_pg_connection *this = pg_get_connection_safe( self );
-	/* returns 0 on failure */
-	if(gvl_PQsendDescribePrepared(this->pgconn, pg_cstr_enc(stmt_name, this->enc_idx)) == 0)
-		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
-
-	pgconn_wait_for_flush( self );
-	return Qnil;
+	return pgconn_send_describe_close_prepared_portal(
+		self, stmt_name, PQsendDescribePrepared,
+		"PQsendDescribePrepared");
 }
 
 
@@ -2105,16 +2262,48 @@ pgconn_send_describe_prepared(VALUE self, VALUE stmt_name)
 static VALUE
 pgconn_send_describe_portal(VALUE self, VALUE portal)
 {
-	t_pg_connection *this = pg_get_connection_safe( self );
-	/* returns 0 on failure */
-	if(gvl_PQsendDescribePortal(this->pgconn, pg_cstr_enc(portal, this->enc_idx)) == 0)
-		pg_raise_conn_error( rb_eUnableToSend, self, "%s", PQerrorMessage(this->pgconn));
+	return pgconn_send_describe_close_prepared_portal(
+		self, portal, PQsendDescribePortal,
+		"PQsendDescribePortal");
+}
 
-	pgconn_wait_for_flush( self );
-	return Qnil;
+#ifdef LIBPQ_HAS_CHUNK_MODE
+/*
+ * call-seq:
+ *    conn.send_close_prepared( statement_name ) -> nil
+ *
+ * Asynchronously send _command_ to the server. Does not block.
+ * Use in combination with +conn.get_result+.
+ *
+ * Available since PostgreSQL-17.
+ */
+static VALUE
+pgconn_send_close_prepared(VALUE self, VALUE stmt_name)
+{
+	return pgconn_send_describe_close_prepared_portal(
+		self, stmt_name, PQsendClosePrepared,
+		"PQsendClosePrepared");
 }
 
 
+/*
+ * call-seq:
+ *    conn.send_close_portal( portal_name ) -> nil
+ *
+ * Asynchronously send _command_ to the server. Does not block.
+ * Use in combination with +conn.get_result+.
+ *
+ * Available since PostgreSQL-17.
+ */
+static VALUE
+pgconn_send_close_portal(VALUE self, VALUE portal)
+{
+	return pgconn_send_describe_close_prepared_portal(
+		self, portal, PQsendClosePortal,
+		"PQsendClosePortal");
+}
+#endif
+
 static VALUE
 pgconn_sync_get_result(VALUE self)
 {
@@ -2122,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);
@@ -2164,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
@@ -2204,6 +2393,7 @@ pgconn_sync_flush(VALUE self)
 	return (ret) ? Qfalse : Qtrue;
 }
 
+#ifndef LIBPQ_HAS_CHUNK_MODE
 static VALUE
 pgconn_sync_cancel(VALUE self)
 {
@@ -2216,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
@@ -2225,6 +2415,7 @@ pgconn_sync_cancel(VALUE self)
 	PQfreeCancel(cancel);
 	return retval;
 }
+#endif
 
 
 /*
@@ -2247,12 +2438,12 @@ 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;
 	}
 
-	hash = rb_hash_new();
+	hash = rb_hash_new_capa(3);
 	relname = rb_str_new2(notification->relname);
 	be_pid = INT2NUM(notification->be_pid);
 	extra = rb_str_new2(notification->extra);
@@ -2267,32 +2458,13 @@ pgconn_notifies(VALUE self)
 	return hash;
 }
 
-#ifndef HAVE_RB_IO_DESCRIPTOR
-static int
-rb_io_descriptor(VALUE io)
-{
-	Check_Type(io, T_FILE);
-	rb_io_t *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 );
 
@@ -2316,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 ) {
@@ -2362,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 *
@@ -2439,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;
 		}
@@ -2476,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);
 		}
 	}
@@ -2504,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);
 }
 
 /*
@@ -2568,7 +2711,7 @@ pgconn_sync_put_copy_data(int argc, VALUE *argv, VALUE self)
 	VALUE value;
 	VALUE buffer = Qnil;
 	VALUE encoder;
-	VALUE intermediate;
+	VALUE intermediate = Qnil;
 	t_pg_coder *p_coder = NULL;
 
 	rb_scan_args( argc, argv, "11", &value, &encoder );
@@ -2603,11 +2746,10 @@ 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));
 
-	RB_GC_GUARD(intermediate);
 	RB_GC_GUARD(buffer);
 
 	return (ret) ? Qtrue : Qfalse;
@@ -2617,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 );
@@ -2624,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 )
 {
@@ -2655,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));
 	}
@@ -2667,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);
 	}
@@ -2702,7 +2872,6 @@ pgconn_set_error_verbosity(VALUE self, VALUE in_verbosity)
 	return INT2FIX(PQsetErrorVerbosity(conn, verbosity));
 }
 
-#ifdef HAVE_PQRESULTVERBOSEERRORMESSAGE
 /*
  * call-seq:
  *    conn.set_error_context_visibility( context_visibility ) -> Integer
@@ -2722,7 +2891,6 @@ pgconn_set_error_verbosity(VALUE self, VALUE in_verbosity)
  *
  * See also corresponding {libpq function}[https://www.postgresql.org/docs/current/libpq-control.html#LIBPQ-PQSETERRORCONTEXTVISIBILITY].
  *
- * Available since PostgreSQL-9.6
  */
 static VALUE
 pgconn_set_error_context_visibility(VALUE self, VALUE in_context_visibility)
@@ -2731,7 +2899,6 @@ pgconn_set_error_context_visibility(VALUE self, VALUE in_context_visibility)
 	PGContextVisibility context_visibility = NUM2INT(in_context_visibility);
 	return INT2FIX(PQsetErrorContextVisibility(conn, context_visibility));
 }
-#endif
 
 /*
  * call-seq:
@@ -2804,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 );
@@ -2863,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;
@@ -2882,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);
@@ -2924,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;
@@ -2966,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 );
@@ -3031,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;
 }
 
 
@@ -3089,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);
@@ -3141,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;
 
@@ -3198,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:
@@ -3217,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 */
@@ -3270,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.
  *
@@ -3310,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
@@ -3459,6 +3625,21 @@ pgconn_async_exec_prepared(int argc, VALUE *argv, VALUE self)
 	return rb_pgresult;
 }
 
+static VALUE
+pgconn_async_describe_close_prepared_potral(VALUE self, VALUE name, VALUE
+(*func)(VALUE, VALUE))
+{
+	VALUE rb_pgresult = Qnil;
+
+	pgconn_discard_results( self );
+	func( self, name );
+	rb_pgresult = pgconn_async_get_last_result( self );
+
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
+	}
+	return rb_pgresult;
+}
 
 /*
  * call-seq:
@@ -3471,16 +3652,7 @@ pgconn_async_exec_prepared(int argc, VALUE *argv, VALUE self)
 static VALUE
 pgconn_async_describe_portal(VALUE self, VALUE portal)
 {
-	VALUE rb_pgresult = Qnil;
-
-	pgconn_discard_results( self );
-	pgconn_send_describe_portal( self, portal );
-	rb_pgresult = pgconn_async_get_last_result( self );
-
-	if ( rb_block_given_p() ) {
-		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
-	}
-	return rb_pgresult;
+	return pgconn_async_describe_close_prepared_potral(self, portal, pgconn_send_describe_portal);
 }
 
 
@@ -3495,27 +3667,64 @@ pgconn_async_describe_portal(VALUE self, VALUE portal)
 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 );
-	rb_pgresult = pgconn_async_get_last_result( self );
+	return pgconn_async_describe_close_prepared_potral(self, stmt_name, pgconn_send_describe_prepared);
+}
 
-	if ( rb_block_given_p() ) {
-		return rb_ensure( rb_yield, rb_pgresult, pg_result_clear, rb_pgresult );
-	}
-	return rb_pgresult;
+#ifdef LIBPQ_HAS_CHUNK_MODE
+/*
+ * call-seq:
+ *    conn.close_prepared( statement_name ) -> PG::Result
+ *
+ * Submits a request to close the specified prepared statement, and waits for completion.
+ * close_prepared allows an application to close a previously prepared statement.
+ * Closing a statement releases all of its associated resources on the server and allows its name to be reused.
+ * It's the same as using the +DEALLOCATE+ SQL statement, but on a lower protocol level.
+ *
+ * +statement_name+ can be "" or +nil+ to reference the unnamed statement.
+ * It is fine if no statement exists with this name, in that case the operation is a no-op.
+ * On success, a PG::Result with status PGRES_COMMAND_OK is returned.
+ *
+ * See also corresponding {libpq function}[https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-PQCLOSEPREPARED].
+ *
+ * Available since PostgreSQL-17.
+ */
+static VALUE
+pgconn_async_close_prepared(VALUE self, VALUE stmt_name)
+{
+	return pgconn_async_describe_close_prepared_potral(self, stmt_name, pgconn_send_close_prepared);
 }
 
+/*
+ * call-seq:
+ *    conn.close_portal( portal_name ) -> PG::Result
+ *
+ * Submits a request to close the specified portal, and waits for completion.
+ *
+ * close_portal allows an application to trigger a close of a previously created portal.
+ * Closing a portal releases all of its associated resources on the server and allows its name to be reused.
+ * (pg does not provide any direct access to portals, but you can use this function to close a cursor created with a DECLARE CURSOR SQL command.)
+ *
+ * +portal_name+ can be "" or +nil+ to reference the unnamed portal.
+ * It is fine if no portal exists with this name, in that case the operation is a no-op.
+ * On success, a PG::Result with status PGRES_COMMAND_OK is returned.
+ *
+ * See also corresponding {libpq function}[https://www.postgresql.org/docs/current/libpq-exec.html#LIBPQ-PQCLOSEPORTAL].
+ *
+ * Available since PostgreSQL-17.
+ */
+static VALUE
+pgconn_async_close_portal(VALUE self, VALUE portal)
+{
+	return pgconn_async_describe_close_prepared_potral(self, portal, pgconn_send_close_portal);
+}
+#endif
 
-#ifdef HAVE_PQSSLATTRIBUTE
 /*
  * call-seq:
  *    conn.ssl_in_use? -> Boolean
  *
  * Returns +true+ if the connection uses SSL/TLS, +false+ if not.
  *
- * Available since PostgreSQL-9.5
  */
 static VALUE
 pgconn_ssl_in_use(VALUE self)
@@ -3549,7 +3758,6 @@ pgconn_ssl_in_use(VALUE self)
  *
  * See also #ssl_attribute_names and the {corresponding libpq function}[https://www.postgresql.org/docs/current/libpq-status.html#LIBPQ-PQSSLATTRIBUTE].
  *
- * Available since PostgreSQL-9.5
  */
 static VALUE
 pgconn_ssl_attribute(VALUE self, VALUE attribute_name)
@@ -3568,7 +3776,6 @@ 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)
@@ -3584,10 +3791,8 @@ pgconn_ssl_attribute_names(VALUE self)
 }
 
 
-#endif
-
 
-#ifdef HAVE_PQENTERPIPELINEMODE
+#ifdef LIBPQ_HAS_PIPELINING
 /*
  * call-seq:
  *    conn.pipeline_status -> Integer
@@ -3620,6 +3825,8 @@ pgconn_pipeline_status(VALUE self)
  * Raises PG::Error and has no effect if the connection is not currently idle, i.e., it has a result ready, or it is waiting for more input from the server, etc.
  * This function does not actually send anything to the server, it just changes the libpq connection state.
  *
+ * See the {PostgreSQL documentation}[https://www.postgresql.org/docs/17/libpq-pipeline-mode.html#LIBPQ-PIPELINE-MODE].
+ *
  * Available since PostgreSQL-14
  */
 static VALUE
@@ -3658,17 +3865,16 @@ pgconn_exit_pipeline_mode(VALUE self)
 
 /*
  * call-seq:
- *    conn.pipeline_sync -> nil
+ *    conn.sync_pipeline_sync -> nil
  *
- * Marks a synchronization point in a pipeline by sending a sync message and flushing the send buffer.
- * This serves as the delimiter of an implicit transaction and an error recovery point; see Section 34.5.1.3 of the PostgreSQL documentation.
- *
- * Raises PG::Error if the connection is not in pipeline mode or sending a sync message failed.
+ * This function has the same behavior as #async_pipeline_sync, but is implemented using the synchronous command processing API of libpq.
+ * See #async_exec for the differences between the two API variants.
+ * It's not recommended to use explicit sync or async variants but #pipeline_sync instead, unless you have a good reason to do so.
  *
  * Available since PostgreSQL-14
  */
 static VALUE
-pgconn_pipeline_sync(VALUE self)
+pgconn_sync_pipeline_sync(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int res = PQpipelineSync(conn);
@@ -3678,9 +3884,36 @@ pgconn_pipeline_sync(VALUE self)
 	return Qnil;
 }
 
+
+#ifdef LIBPQ_HAS_CHUNK_MODE
 /*
  * call-seq:
- *    conn.pipeline_sync -> nil
+ *    conn.send_pipeline_sync -> nil
+ *
+ * Marks a synchronization point in a pipeline by sending a sync message without flushing the send buffer.
+ *
+ * This serves as the delimiter of an implicit transaction and an error recovery point.
+ * Raises PG::Error if the connection is not in pipeline mode or sending a sync message failed.
+ * Note that the message is not itself flushed to the server automatically; use flush if necessary.
+ *
+ * Available since PostgreSQL-17
+ */
+static VALUE
+pgconn_send_pipeline_sync(VALUE self)
+{
+	PGconn *conn = pg_get_pgconn(self);
+	int res = PQsendPipelineSync(conn);
+	if( res != 1 )
+		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
+
+	return Qnil;
+}
+#endif
+
+
+/*
+ * call-seq:
+ *    conn.send_flush_request -> nil
  *
  * Sends a request for the server to flush its output buffer.
  *
@@ -4110,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 );
@@ -4150,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 );
@@ -4231,9 +4464,11 @@ pgconn_set_default_encoding( VALUE self )
  *    res.type_map_for_queries = typemap
  *
  * Set the default TypeMap that is used for type casts of query bind parameters.
+ * It can be overwritten per +type_map+ parameter of #exec_params and siblings.
  *
  * +typemap+ must be a kind of PG::TypeMap .
  *
+ * See also #type_map_for_queries
  */
 static VALUE
 pgconn_type_map_for_queries_set(VALUE self, VALUE typemap)
@@ -4258,6 +4493,9 @@ pgconn_type_map_for_queries_set(VALUE self, VALUE typemap)
  * Returns the default TypeMap that is currently set for type casts of query
  * bind parameters.
  *
+ * Default is PG::TypeMapAllStrings .
+ *
+ * See also #type_map_for_queries=
  */
 static VALUE
 pgconn_type_map_for_queries_get(VALUE self)
@@ -4272,9 +4510,11 @@ pgconn_type_map_for_queries_get(VALUE self)
  *    res.type_map_for_results = typemap
  *
  * Set the default TypeMap that is used for type casts of result values.
+ * It can be overwritten per PG::Result#type_map= .
  *
  * +typemap+ must be a kind of PG::TypeMap .
  *
+ * See also #type_map_for_results
  */
 static VALUE
 pgconn_type_map_for_results_set(VALUE self, VALUE typemap)
@@ -4296,6 +4536,9 @@ pgconn_type_map_for_results_set(VALUE self, VALUE typemap)
  *
  * Returns the default TypeMap that is currently set for type casts of result values.
  *
+ * Default is PG::TypeMapAllStrings .
+ *
+ * See also #type_map_for_results=
  */
 static VALUE
 pgconn_type_map_for_results_get(VALUE self)
@@ -4312,11 +4555,13 @@ pgconn_type_map_for_results_get(VALUE self)
  *
  * Set the default coder that is used for type casting of parameters
  * to #put_copy_data .
+ * It can be overwritten per +encoder+ parameter of #put_copy_data and +coder+ parameter of #copy_data.
  *
  * +encoder+ can be:
  * * a kind of PG::Coder
  * * +nil+ - disable type encoding, data must be a String.
  *
+ * See also #encoder_for_put_copy_data
  */
 static VALUE
 pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE encoder)
@@ -4346,6 +4591,8 @@ pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE encoder)
  * * a kind of PG::Coder
  * * +nil+ - type encoding is disabled, data must be a String.
  *
+ * Default is +nil+ .
+ * See also #encoder_for_put_copy_data=
  */
 static VALUE
 pgconn_encoder_for_put_copy_data_get(VALUE self)
@@ -4361,11 +4608,13 @@ pgconn_encoder_for_put_copy_data_get(VALUE self)
  *
  * Set the default coder that is used for type casting of received data
  * by #get_copy_data .
+ * It can be overwritten per +decoder+ parameter of #get_copy_data and +coder+ parameter of #copy_data.
  *
  * +decoder+ can be:
  * * a kind of PG::Coder
  * * +nil+ - disable type decoding, returned data will be a String.
  *
+ * See also #decoder_for_get_copy_data
  */
 static VALUE
 pgconn_decoder_for_get_copy_data_set(VALUE self, VALUE decoder)
@@ -4395,6 +4644,9 @@ pgconn_decoder_for_get_copy_data_set(VALUE self, VALUE decoder)
  * * a kind of PG::Coder
  * * +nil+ - type encoding is disabled, returned data will be a String.
  *
+ * Default is +nil+ .
+ *
+ * See also #decoder_for_get_copy_data=
  */
 static VALUE
 pgconn_decoder_for_get_copy_data_get(VALUE self)
@@ -4417,7 +4669,7 @@ pgconn_decoder_for_get_copy_data_get(VALUE self)
  *
  * Settings the type of field names affects only future results.
  *
- * See further description at PG::Result#field_name_type=
+ * See further description at PG::Result#field_name_type= and #field_name_type .
  *
  */
 static VALUE
@@ -4428,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);
 
@@ -4450,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;
 	}
@@ -4471,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 */
@@ -4519,12 +4767,17 @@ 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 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);
 	rb_define_method(rb_cPGconn, "connection_used_password", pgconn_connection_used_password, 0);
 	/* rb_define_method(rb_cPGconn, "getssl", pgconn_getssl, 0); */
@@ -4536,6 +4789,10 @@ 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 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
 
 	rb_define_method(rb_cPGconn, "exec", pgconn_async_exec, -1);
 	rb_define_method(rb_cPGconn, "exec_params", pgconn_async_exec_params, -1);
@@ -4543,6 +4800,10 @@ 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 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
 
 	rb_define_alias(rb_cPGconn, "async_exec", "exec");
 	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
@@ -4551,6 +4812,10 @@ 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 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
 
 	rb_define_method(rb_cPGconn, "make_empty_pgresult", pgconn_make_empty_pgresult, 1);
 	rb_define_method(rb_cPGconn, "escape_string", pgconn_s_escape, 1);
@@ -4560,6 +4825,9 @@ 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 LIBPQ_HAS_CHUNK_MODE
+	rb_define_method(rb_cPGconn, "set_chunked_rows_mode", pgconn_set_chunked_rows_mode, 1);
+#endif
 
 	/******     PG::Connection INSTANCE METHODS: Asynchronous Command Processing     ******/
 	rb_define_method(rb_cPGconn, "send_query", pgconn_send_query, -1);
@@ -4579,7 +4847,9 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "discard_results", pgconn_discard_results, 0);
 
 	/******     PG::Connection INSTANCE METHODS: Cancelling Queries in Progress     ******/
+#ifndef LIBPQ_HAS_CHUNK_MODE
 	rb_define_method(rb_cPGconn, "sync_cancel", pgconn_sync_cancel, 0);
+#endif
 
 	/******     PG::Connection INSTANCE METHODS: NOTIFY     ******/
 	rb_define_method(rb_cPGconn, "notifies", pgconn_notifies, 0);
@@ -4591,9 +4861,7 @@ init_pg_connection(void)
 
 	/******     PG::Connection INSTANCE METHODS: Control Functions     ******/
 	rb_define_method(rb_cPGconn, "set_error_verbosity", pgconn_set_error_verbosity, 1);
-#ifdef HAVE_PQRESULTVERBOSEERRORMESSAGE
 	rb_define_method(rb_cPGconn, "set_error_context_visibility", pgconn_set_error_context_visibility, 1 );
-#endif
 	rb_define_method(rb_cPGconn, "trace", pgconn_trace, 1);
 	rb_define_method(rb_cPGconn, "untrace", pgconn_untrace, 0);
 
@@ -4615,22 +4883,21 @@ init_pg_connection(void)
 	rb_define_method(rb_cPGconn, "sync_get_last_result", pgconn_sync_get_last_result, 0);
 	rb_define_method(rb_cPGconn, "get_last_result", pgconn_async_get_last_result, 0);
 	rb_define_alias(rb_cPGconn, "async_get_last_result", "get_last_result");
-#ifdef HAVE_PQENCRYPTPASSWORDCONN
 	rb_define_method(rb_cPGconn, "sync_encrypt_password", pgconn_sync_encrypt_password, -1);
-#endif
 
-#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
 
-#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, "pipeline_sync", pgconn_pipeline_sync, 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 LIBPQ_HAS_CHUNK_MODE
+	rb_define_method(rb_cPGconn, "send_pipeline_sync", pgconn_send_pipeline_sync, 0);
+#endif
 #endif
 
 	/******     PG::Connection INSTANCE METHODS: Large Object Support     ******/