pg 1.5.9 → 1.7.0

data/ext/pg_text_encoder.c

@@ -231,7 +231,7 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
  *
  */
 static int
-pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
+pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate1, int enc_idx)
 {
 	if(out){
 		double dvalue = NUM2DBL(value);
@@ -239,7 +239,6 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 		int neg = 0;
 		int exp2i, exp10i, i;
 		unsigned long long ll, remainder, oldval;
-		VALUE intermediate;
 
 		/* Cast to the same strings as value.to_s . */
 		if( isinf(dvalue) ){
@@ -283,6 +282,7 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 
 		if( exp10i <= -5 || exp10i >= 15 ) {
 			/* Write the float in exponent format (1.23e45) */
+			VALUE intermediate;
 
 			/* write fraction digits from right to left */
 			for( i = MAX_DOUBLE_DIGITS; i > 1; i--){
@@ -381,8 +381,8 @@ pg_text_enc_numeric(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 static VALUE
 init_pg_text_encoder_numeric(VALUE rb_mPG_TextDecoder)
 {
+	rb_gc_register_address(&s_str_F);
 	s_str_F = rb_str_freeze(rb_str_new_cstr("F"));
-	rb_global_variable(&s_str_F);
 	rb_funcall(rb_mPG, rb_intern("require_bigdecimal_without_warning"), 0);
 	s_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 
@@ -430,9 +430,14 @@ pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 		}
 		return (int)(optr - out);
 	}else{
+		long size;
 		*intermediate = rb_obj_as_string(value);
+		size = RSTRING_LEN(*intermediate);
+
 		/* The output starts with "\x" and each character is converted to hex. */
-		return 2 + RSTRING_LENINT(*intermediate) * 2;
+		if( size > INT_MAX / 2 - 2 )
+			rb_raise( rb_eArgError, "too large input string for PG::TextEncoder::Bytea: %ld", size );
+		return (int)(2 + size * 2);
 	}
 }
 
@@ -537,7 +542,7 @@ quote_string(t_pg_coder *this, VALUE value, VALUE string, char *current_out, int
 }
 
 static char *
-write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE string, int quote, int enc_idx)
+write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE string, int quote, int enc_idx, int dimension)
 {
 	int i;
 
@@ -545,6 +550,10 @@ write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE st
 	current_out = pg_rb_str_ensure_capa( string, 2, current_out, NULL );
 	*current_out++ = '{';
 
+	if( RARRAY_LEN(value) == 0 && this->dimensions >= 0 && dimension != this->dimensions ){
+		rb_raise(rb_eArgError, "less array dimensions to encode (%d) than expected (%d)", dimension, this->dimensions);
+	}
+
 	for( i=0; i<RARRAY_LEN(value); i++){
 		VALUE entry = rb_ary_entry(value, i);
 
@@ -554,17 +563,26 @@ write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE st
 		}
 
 		switch(TYPE(entry)){
-			case T_ARRAY:
-				current_out = write_array(this, entry, current_out, string, quote, enc_idx);
-			break;
 			case T_NIL:
+				if( this->dimensions >= 0 && dimension != this->dimensions ){
+					rb_raise(rb_eArgError, "less array dimensions to encode (%d) than expected (%d)", dimension, this->dimensions);
+				}
 				current_out = pg_rb_str_ensure_capa( string, 4, current_out, NULL );
 				*current_out++ = 'N';
 				*current_out++ = 'U';
 				*current_out++ = 'L';
 				*current_out++ = 'L';
 				break;
+			case T_ARRAY:
+				if( this->dimensions < 0 || dimension < this->dimensions ){
+					current_out = write_array(this, entry, current_out, string, quote, enc_idx, dimension+1);
+					break;
+				}
+				/* Number of dimensions reached -> handle array as normal value */
 			default:
+				if( this->dimensions >= 0 && dimension != this->dimensions ){
+					rb_raise(rb_eArgError, "less array dimensions to encode (%d) than expected (%d)", dimension, this->dimensions);
+				}
 				current_out = quote_string( this->elem, entry, string, current_out, quote, quote_array_buffer, this, enc_idx );
 		}
 	}
@@ -596,7 +614,7 @@ pg_text_enc_array(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 		VALUE out_str = rb_str_new(NULL, 0);
 		PG_ENCODING_SET_NOCHECK(out_str, enc_idx);
 
-		end_ptr = write_array(this, value, RSTRING_PTR(out_str), out_str, this->needs_quotation, enc_idx);
+		end_ptr = write_array(this, value, RSTRING_PTR(out_str), out_str, this->needs_quotation, enc_idx, 1);
 
 		rb_str_set_len( out_str, end_ptr - RSTRING_PTR(out_str) );
 		*intermediate = out_str;
@@ -771,7 +789,7 @@ pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedi
 	if(out){
 		/* Second encoder pass, if required */
 		strlen = enc_func(this->elem, value, out, intermediate, enc_idx);
-		base64_encode( out, out, strlen );
+		rbpg_base64_encode( out, out, strlen );
 
 		return BASE64_ENCODED_SIZE(strlen);
 	} else {
@@ -786,7 +804,7 @@ pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedi
 			out_str = rb_str_new(NULL, BASE64_ENCODED_SIZE(strlen));
 			PG_ENCODING_SET_NOCHECK(out_str, enc_idx);
 
-			base64_encode( RSTRING_PTR(out_str), RSTRING_PTR(subint), strlen);
+			rbpg_base64_encode( RSTRING_PTR(out_str), RSTRING_PTR(subint), strlen);
 			*intermediate = out_str;
 
 			return -1;

data/ext/pg_tuple.c

@@ -125,17 +125,17 @@ static const rb_data_type_t pg_tuple_type = {
 		pg_tuple_gc_mark,
 		pg_tuple_gc_free,
 		pg_tuple_memsize,
-		pg_compact_callback(pg_tuple_gc_compact),
+		pg_tuple_gc_compact,
 	},
 	0, 0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*
  * Document-method: allocate
  *
  * call-seq:
- *   PG::VeryTuple.allocate -> obj
+ *   PG::Tuple.allocate -> obj
  */
 static VALUE
 pg_tuple_s_allocate( VALUE klass )
@@ -242,10 +242,10 @@ pg_tuple_materialize(VALUE self)
  * An integer +key+ is interpreted as column index.
  * Negative values of index count from the end of the array.
  *
- * Depending on Result#field_name_type= a string or symbol +key+ is interpreted as column name.
+ * Depending on PG::Result#field_name_type= a string or symbol +key+ is interpreted as column name.
  *
  * If the key can't be found, there are several options:
- * With no other arguments, it will raise a IndexError exception;
+ * With no other arguments, it will raise a +IndexError+ exception;
  * if default is given, then that will be returned;
  * if the optional code block is specified, then that will be run and its result returned.
  */
@@ -302,7 +302,7 @@ pg_tuple_fetch(int argc, VALUE *argv, VALUE self)
  * An integer +key+ is interpreted as column index.
  * Negative values of index count from the end of the array.
  *
- * Depending on Result#field_name_type= a string or symbol +key+ is interpreted as column name.
+ * Depending on PG::Result#field_name_type= a string or symbol +key+ is interpreted as column name.
  *
  * If the key can't be found, it returns +nil+ .
  */
@@ -405,7 +405,7 @@ pg_tuple_each_value(VALUE self)
  *    tup.values  -> Array
  *
  * Returns the values of this tuple as Array.
- * +res.tuple(i).values+ is equal to +res.tuple_values(i)+ .
+ * <tt>res.tuple(i).values</tt> is equal to <tt>res.tuple_values(i)</tt> .
  */
 static VALUE
 pg_tuple_values(VALUE self)
@@ -474,7 +474,7 @@ pg_tuple_dump(VALUE self)
 	values = rb_ary_new4(this->num_fields, &this->values[0]);
 	a = rb_ary_new3(2, field_names, values);
 
-        rb_copy_generic_ivar(a, self);
+	rb_copy_generic_ivar(a, self);
 
 	return a;
 }
@@ -510,7 +510,7 @@ pg_tuple_load(VALUE self, VALUE a)
 	if (RARRAY_LENINT(field_names) != num_fields)
 		rb_raise(rb_eTypeError, "different number of fields and values");
 
-	field_map = rb_hash_new();
+	field_map = rb_hash_new_capa(num_fields);
 	for( i = 0; i < num_fields; i++ ){
 		rb_hash_aset(field_map, RARRAY_AREF(field_names, i), INT2FIX(i));
 	}

data/ext/pg_type_map.c

@@ -33,11 +33,11 @@ const rb_data_type_t pg_typemap_type = {
 		pg_typemap_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_typemap_memsize,
-		pg_compact_callback(pg_typemap_compact),
+		pg_typemap_compact,
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 VALUE rb_cTypeMap;
@@ -115,6 +115,45 @@ pg_typemap_s_allocate( VALUE klass )
 	return self;
 }
 
+/*
+ * call-seq:
+ *    res.query_param_encoders(params)
+ *
+ * Retrieve the encoders that are used to encode the given values to be submitted to the database server.
+ * The selection of the encoders is defined in the derived type map class.
+ *
+ * +params+ must be an Array of values to be encoded.
+ * It's like +params+ given to exec_params .
+ *
+ * Returns an Array with the same length as +params+.
+ *
+ */
+static VALUE
+pg_typemap_query_param_encoders( VALUE self, VALUE params )
+{
+	t_typemap *this = RTYPEDDATA_DATA( self );
+	int nParams;
+	int i=0;
+	VALUE res;
+
+	Check_Type(params, T_ARRAY);
+
+	this->funcs.fit_to_query( self, params );
+
+	nParams = RARRAY_LENINT(params);
+	res = rb_ary_new2(nParams);
+
+	for ( i = 0; i < nParams; i++ ) {
+		t_pg_coder *conv;
+		VALUE param_value = rb_ary_entry(params, i);
+
+		/* Let the given typemap select a coder for this param */
+		conv = this->funcs.typecast_query_param(this, param_value, i);
+		rb_ary_push(res, conv ? conv->coder_obj : Qnil);
+	}
+	return res;
+}
+
 /*
  * call-seq:
  *    res.default_type_map = typemap
@@ -187,11 +226,14 @@ init_pg_type_map(void)
 	 *
 	 * This is the base class for type maps.
 	 * See derived classes for implementations of different type cast strategies
-	 * ( PG::TypeMapByColumn, PG::TypeMapByOid ).
+	 * ( PG::TypeMapByColumn, PG::TypeMapByOid, etc.).
+	 *
+	 * Find more type maps in the {README}[rdoc-ref:README.md@Type+Casts].
 	 *
 	 */
 	rb_cTypeMap = rb_define_class_under( rb_mPG, "TypeMap", rb_cObject );
 	rb_define_alloc_func( rb_cTypeMap, pg_typemap_s_allocate );
+	rb_define_method( rb_cTypeMap, "query_param_encoders", pg_typemap_query_param_encoders, 1 );
 
 	rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable");
 	rb_define_method( rb_mDefaultTypeMappable, "default_type_map=", pg_typemap_default_type_map_set, 1 );

data/ext/pg_type_map_all_strings.c

@@ -14,11 +14,11 @@ static const rb_data_type_t pg_tmas_type = {
 		pg_typemap_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_typemap_memsize,
-		pg_compact_callback(pg_typemap_compact),
+		pg_typemap_compact,
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 VALUE rb_cTypeMapAllStrings;
@@ -125,6 +125,6 @@ init_pg_type_map_all_strings(void)
 	rb_cTypeMapAllStrings = rb_define_class_under( rb_mPG, "TypeMapAllStrings", rb_cTypeMap );
 	rb_define_alloc_func( rb_cTypeMapAllStrings, pg_tmas_s_allocate );
 
-	pg_typemap_all_strings = rb_obj_freeze( rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 ));
 	rb_gc_register_address( &pg_typemap_all_strings );
+	pg_typemap_all_strings = rb_obj_freeze( rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 ));
 }

data/ext/pg_type_map_by_class.c

@@ -153,11 +153,11 @@ static const rb_data_type_t pg_tmbk_type = {
 		pg_tmbk_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_tmbk_memsize,
-		pg_compact_callback(pg_tmbk_compact),
+		pg_tmbk_compact,
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE

data/ext/pg_type_map_by_column.c

@@ -54,7 +54,8 @@ pg_tmbc_fit_to_query( VALUE self, VALUE params )
 	t_tmbc *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 
-	nfields = (int)RARRAY_LEN( params );
+	Check_Type(params, T_ARRAY);
+	nfields = RARRAY_LENINT( params );
 	if ( this->nfields != nfields ) {
 		rb_raise( rb_eArgError, "number of result fields (%d) does not match number of mapped columns (%d)",
 				nfields, this->nfields );
@@ -228,11 +229,11 @@ static const rb_data_type_t pg_tmbc_type = {
 		pg_tmbc_mark,
 		pg_tmbc_free,
 		pg_tmbc_memsize,
-		pg_compact_callback(pg_tmbc_compact),
+		pg_tmbc_compact,
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE

data/ext/pg_type_map_by_mri_type.c

@@ -130,7 +130,7 @@ static const rb_data_type_t pg_tmbmt_type = {
 		pg_tmbmt_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_tmbmt_memsize,
-		pg_compact_callback(pg_tmbmt_compact),
+		pg_tmbmt_compact,
 	},
 	&pg_typemap_type,
 	0,

data/ext/pg_type_map_by_oid.c

@@ -190,11 +190,11 @@ static const rb_data_type_t pg_tmbo_type = {
 		pg_tmbo_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_tmbo_memsize,
-		pg_compact_callback(pg_tmbo_compact),
+		pg_tmbo_compact,
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -315,6 +315,8 @@ pg_tmbo_coders( VALUE self )
  * The type map will do Hash lookups for each result value, if the number of rows
  * is below or equal +number+.
  *
+ * Default is 10.
+ *
  */
 static VALUE
 pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )

data/ext/pg_type_map_in_ruby.c

@@ -40,11 +40,11 @@ static const rb_data_type_t pg_tmir_type = {
 		pg_typemap_mark,
 		RUBY_TYPED_DEFAULT_FREE,
 		pg_tmir_memsize,
-		pg_compact_callback(pg_tmir_compact),
+		pg_tmir_compact,
 	},
 	&pg_typemap_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /*

data/ext/pg_util.c

@@ -15,7 +15,7 @@ static const char base64_encode_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijk
  * in-place (with _out_ == _in_).
  */
 void
-base64_encode( char *out, const char *in, int len)
+rbpg_base64_encode( char *out, const char *in, int len)
 {
 	const unsigned char *in_ptr = (const unsigned char *)in + len;
 	char *out_ptr = out + BASE64_ENCODED_SIZE(len);
@@ -72,7 +72,7 @@ static const unsigned char base64_decode_table[] =
  * It is possible to decode a string in-place (with _out_ == _in_).
  */
 int
-base64_decode( char *out, const char *in, unsigned int len)
+rbpg_base64_decode( char *out, const char *in, unsigned int len)
 {
 	unsigned char a, b, c, d;
 	const unsigned char *in_ptr = (const unsigned char *)in;

data/ext/pg_util.h

@@ -57,8 +57,8 @@
 #define BASE64_ENCODED_SIZE(strlen) (((strlen) + 2) / 3 * 4)
 #define BASE64_DECODED_SIZE(base64len) (((base64len) + 3) / 4 * 3)
 
-void base64_encode( char *out, const char *in, int len);
-int base64_decode( char *out, const char *in, unsigned int len);
+void rbpg_base64_encode( char *out, const char *in, int len);
+int rbpg_base64_decode( char *out, const char *in, unsigned int len);
 
 int rbpg_strncasecmp(const char *s1, const char *s2, size_t n);
 

data/lib/pg/basic_type_map_based_on_result.rb

@@ -64,4 +64,9 @@ class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
 			add_coder(coder)
 		end
 	end
+
+	# Returns the PG::BasicTypeRegistry::CoderMapsBundle used to translate result OIDs to encoders.
+	def coder_maps_bundle
+		@coder_maps
+	end
 end

data/lib/pg/basic_type_map_for_queries.rb

@@ -53,14 +53,23 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		@coder_maps = build_coder_maps(connection_or_coder_maps, registry: registry)
 		@array_encoders_by_klass = array_encoders_by_klass
 		@encode_array_as = :array
-		@if_undefined = if_undefined || method(:raise_undefined_type).to_proc
+		@if_undefined = if_undefined || UndefinedDefault
 		init_encoders
 	end
 
-	private def raise_undefined_type(oid_name, format)
-		raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
+	# Returns the PG::BasicTypeRegistry::CoderMapsBundle used to translate encoders to OIDs.
+	def coder_maps_bundle
+		@coder_maps
 	end
 
+	class UndefinedDefault
+		def self.call(oid_name, format)
+			raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
+		end
+	end
+
+	private_constant :UndefinedDefault
+
 	# Change the mechanism that is used to encode ruby array values
 	#
 	# Possible values:
@@ -173,13 +182,14 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 	end
 
 	DEFAULT_TYPE_MAP = PG.make_shareable({
-		TrueClass => [1, 'bool', 'bool'],
-		FalseClass => [1, 'bool', 'bool'],
+		TrueClass => [0, 'bool', 'bool'],
+		FalseClass => [0, 'bool', 'bool'],
 		# We use text format and no type OID for numbers, because setting the OID can lead
 		# to unnecessary type conversions on server side.
 		Integer => [0, 'int8'],
 		Float => [0, 'float8'],
 		Time => [0, 'timestamptz'],
+		Date => [0, 'date'],
 		# We use text format and no type OID for IPAddr, because setting the OID can lead
 		# to unnecessary inet/cidr conversions on the server side.
 		IPAddr => [0, 'inet'],
@@ -196,6 +206,7 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		String => [0, '_text'],
 		Float => [0, '_float8'],
 		Time => [0, '_timestamptz'],
+		Date => [0, '_date'],
 		IPAddr => [0, '_inet'],
 	}.merge(has_bigdecimal ? {BigDecimal => [0, '_numeric']} : {}))
 	private_constant :DEFAULT_ARRAY_TYPE_MAP

data/lib/pg/basic_type_map_for_results.rb

@@ -101,4 +101,9 @@ class PG::BasicTypeMapForResults < PG::TypeMapByOid
 		typenames = @coder_maps.typenames_by_oid
 		self.default_type_map = WarningTypeMap.new(typenames)
 	end
+
+	# Returns the PG::BasicTypeRegistry::CoderMapsBundle used to translate result OIDs to decoders.
+	def coder_maps_bundle
+		@coder_maps
+	end
 end

data/lib/pg/basic_type_registry.rb

@@ -127,8 +127,8 @@ class PG::BasicTypeRegistry
 			@maps = [
 				[0, :encoder, PG::TextEncoder::Array],
 				[0, :decoder, PG::TextDecoder::Array],
-				[1, :encoder, nil],
-				[1, :decoder, nil],
+				[1, :encoder, PG::BinaryEncoder::Array],
+				[1, :decoder, PG::BinaryDecoder::Array],
 			].inject([]) do |h, (format, direction, arraycoder)|
 				coders = registry.coders_for(format, direction) || {}
 				h[format] ||= {}

data/lib/pg/cancel_connection.rb

@@ -0,0 +1,53 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'pg' unless defined?( PG )
+
+if defined?(PG::CancelConnection)
+	class PG::CancelConnection
+		include PG::Connection::Pollable
+
+		alias c_initialize initialize
+
+		def initialize(conn)
+			c_initialize(conn)
+
+			# A cancel connection is always to one destination server only.
+			# Prepare conninfo_hash with just enough information to allow a shared polling_loop.
+			@host = conn.host
+			@hostaddr = conn.hostaddr
+			@port = conn.port
+
+			@conninfo_hash = {
+				host: @host,
+				hostaddr: @hostaddr,
+				port: @port.to_s,
+				connect_timeout: conn.conninfo_hash[:connect_timeout],
+			}
+		end
+
+		# call-seq:
+		#    conn.cancel
+		#
+		# Requests that the server abandons processing of the current command in a blocking manner.
+		#
+		# If the cancel request wasn't successfully dispatched an error message is raised.
+		#
+		# Successful dispatch of the cancellation is no guarantee that the request will have any effect, however.
+		# If the cancellation is effective, the command being canceled will terminate early and raises an error.
+		# If the cancellation fails (say, because the server was already done processing the command), then there will be no visible result at all.
+		#
+		def cancel
+			start
+			polling_loop(:poll)
+		end
+		alias async_cancel cancel
+
+		# These private methods are there to allow a shared polling_loop.
+		private
+		attr_reader :host
+		attr_reader :hostaddr
+		attr_reader :port
+		attr_reader :conninfo_hash
+	end
+end

data/lib/pg/coder.rb

@@ -72,16 +72,18 @@ module PG
 
 	class CompositeCoder < Coder
 		def to_h
-			{ **super,
+			h = { **super,
 				elements_type: elements_type,
 				needs_quotation: needs_quotation?,
 				delimiter: delimiter,
 			}
+			h[:dimensions] = dimensions if dimensions # Write only when set, for Marshal compat with pg<1.6
+			h
 		end
 
 		def inspect
 			str = super
-			str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation"
+			str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation#{dimensions && " #{dimensions} dimensions"}"
 			str
 		end
 	end