pg 1.5.4 → 1.6.3

data/ext/pg_text_encoder.c

@@ -119,6 +119,10 @@ pg_text_enc_boolean(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 int
 pg_coder_enc_to_s(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
+	/* Attention:
+	 * In contrast to all other encoders, the "this" pointer of this encoder can be NULL.
+	 * This is because it is used as a fall-back if no encoder is defined.
+	 */
 	VALUE str = rb_obj_as_string(value);
 	if( ENCODING_GET(str) == enc_idx ){
 		*intermediate = str;
@@ -227,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);
@@ -235,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) ){
@@ -279,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--){
@@ -345,6 +349,8 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
  *
  * It converts Integer, Float and BigDecimal objects.
  * All other objects are expected to respond to +to_s+.
+ *
+ * As soon as this class is used, it requires the 'bigdecimal' gem.
  */
 static int
 pg_text_enc_numeric(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
@@ -377,7 +383,7 @@ init_pg_text_encoder_numeric(VALUE rb_mPG_TextDecoder)
 {
 	s_str_F = rb_str_freeze(rb_str_new_cstr("F"));
 	rb_global_variable(&s_str_F);
-	rb_require("bigdecimal");
+	rb_funcall(rb_mPG, rb_intern("require_bigdecimal_without_warning"), 0);
 	s_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
 
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Numeric", rb_cPG_SimpleEncoder ); */
@@ -437,7 +443,7 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 	t_pg_composite_coder *this = _this;
 	char *ptr1;
 	char *ptr2;
-	int backslashs = 0;
+	int backslashes = 0;
 	int needquote;
 
 	/* count data plus backslashes; detect chars needing quotes */
@@ -454,7 +460,7 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 
 		if (ch == '"' || ch == '\\'){
 			needquote = 1;
-			backslashs++;
+			backslashes++;
 		} else if (ch == '{' || ch == '}' || ch == this->delimiter ||
 					ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\v' || ch == '\f'){
 			needquote = 1;
@@ -463,12 +469,12 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 
 	if( needquote ){
 		ptr1 = p_in + strlen;
-		ptr2 = p_out + strlen + backslashs + 2;
+		ptr2 = p_out + strlen + backslashes + 2;
 		/* Write end quote */
 		*--ptr2 = '"';
 
 		/* Then store the escaped string on the final position, walking
-			* right to left, until all backslashs are placed. */
+			* right to left, until all backslashes are placed. */
 		while( ptr1 != p_in ) {
 			*--ptr2 = *--ptr1;
 			if(*ptr2 == '"' || *ptr2 == '\\'){
@@ -477,7 +483,7 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 		}
 		/* Write start quote */
 		*p_out = '"';
-		return strlen + backslashs + 2;
+		return strlen + backslashes + 2;
 	} else {
 		if( p_in != p_out )
 			memcpy( p_out, p_in, strlen );
@@ -531,7 +537,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;
 
@@ -539,6 +545,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);
 
@@ -548,17 +558,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 );
 		}
 	}
@@ -590,7 +609,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;
@@ -692,22 +711,22 @@ static int
 quote_literal_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 	char *ptr1;
 	char *ptr2;
-	int backslashs = 0;
+	int backslashes = 0;
 
 	/* count required backlashs */
 	for(ptr1 = p_in; ptr1 != p_in + strlen; ptr1++) {
 		if (*ptr1 == '\''){
-			backslashs++;
+			backslashes++;
 		}
 	}
 
 	ptr1 = p_in + strlen;
-	ptr2 = p_out + strlen + backslashs + 2;
+	ptr2 = p_out + strlen + backslashes + 2;
 	/* Write end quote */
 	*--ptr2 = '\'';
 
 	/* Then store the escaped string on the final position, walking
-		* right to left, until all backslashs are placed. */
+		* right to left, until all backslashes are placed. */
 	while( ptr1 != p_in ) {
 		*--ptr2 = *--ptr1;
 		if(*ptr2 == '\''){
@@ -716,7 +735,7 @@ quote_literal_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 	}
 	/* Write start quote */
 	*p_out = '\'';
-	return strlen + backslashs + 2;
+	return strlen + backslashes + 2;
 }
 
 
@@ -765,7 +784,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 {
@@ -780,7 +799,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,7 +125,7 @@ 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,
@@ -135,7 +135,7 @@ static const rb_data_type_t pg_tuple_type = {
  * 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,7 +33,7 @@ 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,
@@ -187,7 +187,9 @@ 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 );

data/ext/pg_type_map_all_strings.c

@@ -14,7 +14,7 @@ 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,

data/ext/pg_type_map_by_class.c

@@ -153,7 +153,7 @@ 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,

data/ext/pg_type_map_by_column.c

@@ -54,6 +54,7 @@ pg_tmbc_fit_to_query( VALUE self, VALUE params )
 	t_tmbc *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 
+	Check_Type(params, T_ARRAY);
 	nfields = (int)RARRAY_LEN( params );
 	if ( this->nfields != nfields ) {
 		rb_raise( rb_eArgError, "number of result fields (%d) does not match number of mapped columns (%d)",
@@ -228,7 +229,7 @@ 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,

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,7 +190,7 @@ 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,
@@ -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,7 +40,7 @@ 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,

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_for_queries.rb

@@ -53,14 +53,18 @@ 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}"
+	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:
@@ -166,6 +170,12 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 				@textarray_encoder
 	end
 
+	begin
+		PG.require_bigdecimal_without_warning
+		has_bigdecimal = true
+	rescue LoadError
+	end
+
 	DEFAULT_TYPE_MAP = PG.make_shareable({
 		TrueClass => [1, 'bool', 'bool'],
 		FalseClass => [1, 'bool', 'bool'],
@@ -173,7 +183,6 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		# to unnecessary type conversions on server side.
 		Integer => [0, 'int8'],
 		Float => [0, 'float8'],
-		BigDecimal => [0, 'numeric'],
 		Time => [0, 'timestamptz'],
 		# 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.
@@ -181,7 +190,7 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		Hash => [0, 'json'],
 		Array => :get_array_type,
 		BinaryData => [1, 'bytea'],
-	})
+	}.merge(has_bigdecimal ? {BigDecimal => [0, 'numeric']} : {}))
 	private_constant :DEFAULT_TYPE_MAP
 
 	DEFAULT_ARRAY_TYPE_MAP = PG.make_shareable({
@@ -190,9 +199,8 @@ class PG::BasicTypeMapForQueries < PG::TypeMapByClass
 		Integer => [0, '_int8'],
 		String => [0, '_text'],
 		Float => [0, '_float8'],
-		BigDecimal => [0, '_numeric'],
 		Time => [0, '_timestamptz'],
 		IPAddr => [0, '_inet'],
-	})
+	}.merge(has_bigdecimal ? {BigDecimal => [0, '_numeric']} : {}))
 	private_constant :DEFAULT_ARRAY_TYPE_MAP
 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] ||= {}
@@ -171,7 +171,14 @@ class PG::BasicTypeRegistry
 	include Checker
 
 	def initialize
-		# The key of these hashs maps to the `typname` column from the table pg_type.
+		# @coders_by_name has a content of
+		#    Array< Hash< Symbol: Hash< String: Coder > > >
+		#
+		# The layers are:
+		#   * index of Array is 0 (text) and 1 (binary)
+		#   * Symbol key in the middle Hash is :encoder and :decoder
+		#   * String key in the inner Hash corresponds to the `typname` column in the table pg_type
+		#   * Coder value in the inner Hash is the associated coder object
 		@coders_by_name = []
 	end
 
@@ -225,7 +232,11 @@ class PG::BasicTypeRegistry
 		alias_type    0, 'int8', 'int2'
 		alias_type    0, 'oid',  'int2'
 
-		register_type 0, 'numeric', PG::TextEncoder::Numeric, PG::TextDecoder::Numeric
+		begin
+			PG.require_bigdecimal_without_warning
+			register_type 0, 'numeric', PG::TextEncoder::Numeric, PG::TextDecoder::Numeric
+		rescue LoadError
+		end
 		register_type 0, 'text', PG::TextEncoder::String, PG::TextDecoder::String
 		alias_type 0, 'varchar', 'text'
 		alias_type 0, 'char', 'text'
@@ -267,6 +278,7 @@ class PG::BasicTypeRegistry
 		register_type 0, 'inet', PG::TextEncoder::Inet, PG::TextDecoder::Inet
 		alias_type 0, 'cidr', 'inet'
 
+		register_type 0, 'record', PG::TextEncoder::Record, PG::TextDecoder::Record
 
 
 		register_type 1, 'int2', PG::BinaryEncoder::Int2, PG::BinaryDecoder::Integer

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