pg 1.2.3-x86-mingw32 → 1.3.0.rc1-x86-mingw32

data/ext/pg_type_map_by_oid.c

@@ -46,7 +46,7 @@ pg_tmbo_lookup_oid(t_tmbo *this, int format, Oid oid)
 	} else {
 		VALUE obj = rb_hash_lookup( this->format[format].oid_to_coder, UINT2NUM( oid ));
 		/* obj must be nil or some kind of PG::Coder, this is checked at insertion */
-		conv = NIL_P(obj) ? NULL : DATA_PTR(obj);
+		conv = NIL_P(obj) ? NULL : RTYPEDDATA_DATA(obj);
 		/* Write the retrieved coder to the cache */
 		p_ce->oid = oid;
 		p_ce->p_coder = conv;
@@ -70,7 +70,7 @@ pg_tmbo_build_type_map_for_result2( t_tmbo *this, PGresult *pgresult )
 	p_colmap->typemap.default_typemap = pg_typemap_all_strings;
 
 	colmap = pg_tmbc_allocate();
-	DATA_PTR(colmap) = p_colmap;
+	RTYPEDDATA_DATA(colmap) = p_colmap;
 
 	for(i=0; i<nfields; i++)
 	{
@@ -113,18 +113,18 @@ pg_tmbo_result_value(t_typemap *p_typemap, VALUE result, int tuple, int field)
 		return dec_func( p_coder, val, len, tuple, field, p_result->enc_idx );
 	}
 
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	return default_tm->funcs.typecast_result_value( default_tm, result, tuple, field );
 }
 
 static VALUE
 pg_tmbo_fit_to_result( VALUE self, VALUE result )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	PGresult *pgresult = pgresult_get( result );
 
-	/* Ensure that the default type map fits equaly. */
-	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	VALUE sub_typemap = default_tm->funcs.fit_to_result( this->typemap.default_typemap, result );
 
 	if( PQntuples( pgresult ) <= this->max_rows_for_online_lookup ){
@@ -137,7 +137,7 @@ pg_tmbo_fit_to_result( VALUE self, VALUE result )
 			/* The default type map built a new object, so we need to propagate it
 			 * and build a copy of this type map. */
 			VALUE new_typemap = pg_tmbo_s_allocate( rb_cTypeMapByOid );
-			t_tmbo *p_new_typemap = DATA_PTR(new_typemap);
+			t_tmbo *p_new_typemap = RTYPEDDATA_DATA(new_typemap);
 			*p_new_typemap = *this;
 			p_new_typemap->typemap.default_typemap = sub_typemap;
 			return new_typemap;
@@ -147,23 +147,56 @@ pg_tmbo_fit_to_result( VALUE self, VALUE result )
 		 * uses a fast array lookup.
 		 */
 		VALUE new_typemap = pg_tmbo_build_type_map_for_result2( this, pgresult );
-		t_tmbo *p_new_typemap = DATA_PTR(new_typemap);
+		t_tmbo *p_new_typemap = RTYPEDDATA_DATA(new_typemap);
 		p_new_typemap->typemap.default_typemap = sub_typemap;
 		return new_typemap;
 	}
 }
 
 static void
-pg_tmbo_mark( t_tmbo *this )
+pg_tmbo_mark( void *_this )
 {
+	t_tmbo *this = (t_tmbo *)_this;
 	int i;
 
-	rb_gc_mark(this->typemap.default_typemap);
+	pg_typemap_mark(&this->typemap);
 	for( i=0; i<2; i++){
-		rb_gc_mark(this->format[i].oid_to_coder);
+		rb_gc_mark_movable(this->format[i].oid_to_coder);
 	}
 }
 
+static size_t
+pg_tmbo_memsize( const void *_this )
+{
+	const t_tmbo *this = (const t_tmbo *)_this;
+	return sizeof(*this);
+}
+
+static void
+pg_tmbo_compact( void *_this )
+{
+	t_tmbo *this = (t_tmbo *)_this;
+	int i;
+
+	pg_typemap_compact(&this->typemap);
+	for( i=0; i<2; i++){
+		pg_gc_location(this->format[i].oid_to_coder);
+	}
+}
+
+static const rb_data_type_t pg_tmbo_type = {
+	"PG::TypeMapByOid",
+	{
+		pg_tmbo_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_tmbo_memsize,
+		pg_compact_callback(pg_tmbo_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE
 pg_tmbo_s_allocate( VALUE klass )
 {
@@ -171,7 +204,7 @@ pg_tmbo_s_allocate( VALUE klass )
 	VALUE self;
 	int i;
 
-	self = Data_Make_Struct( klass, t_tmbo, pg_tmbo_mark, -1, this );
+	self = TypedData_Make_Struct( klass, t_tmbo, &pg_tmbo_type, this );
 
 	this->typemap.funcs.fit_to_result = pg_tmbo_fit_to_result;
 	this->typemap.funcs.fit_to_query = pg_typemap_fit_to_query;
@@ -205,15 +238,11 @@ static VALUE
 pg_tmbo_add_coder( VALUE self, VALUE coder )
 {
 	VALUE hash;
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	t_pg_coder *p_coder;
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
-	if( !rb_obj_is_kind_of(coder, rb_cPG_Coder) )
-		rb_raise(rb_eArgError, "invalid type %s (should be some kind of PG::Coder)",
-							rb_obj_classname( coder ));
-
-	Data_Get_Struct(coder, t_pg_coder, p_coder);
+	TypedData_Get_Struct(coder, t_pg_coder, &pg_coder_type, p_coder);
 
 	if( p_coder->format < 0 || p_coder->format > 1 )
 		rb_raise(rb_eArgError, "invalid format code %d", p_coder->format);
@@ -243,7 +272,7 @@ pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
 {
 	VALUE hash;
 	VALUE coder;
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	int i_format = NUM2INT(format);
 	struct pg_tmbo_oid_cache_entry *p_ce;
 
@@ -269,7 +298,7 @@ pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
 static VALUE
 pg_tmbo_coders( VALUE self )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 
 	return rb_ary_concat(
 			rb_funcall(this->format[0].oid_to_coder, rb_intern("values"), 0),
@@ -288,7 +317,7 @@ pg_tmbo_coders( VALUE self )
 static VALUE
 pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	this->max_rows_for_online_lookup = NUM2INT(value);
 	return value;
 }
@@ -300,7 +329,7 @@ pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
 static VALUE
 pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 	return INT2NUM(this->max_rows_for_online_lookup);
 }
 
@@ -315,7 +344,7 @@ pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
 static VALUE
 pg_tmbo_build_column_map( VALUE self, VALUE result )
 {
-	t_tmbo *this = DATA_PTR( self );
+	t_tmbo *this = RTYPEDDATA_DATA( self );
 
 	if ( !rb_obj_is_kind_of(result, rb_cPGresult) ) {
 		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::Result)",

data/ext/pg_type_map_in_ruby.c

@@ -19,6 +19,33 @@ typedef struct {
 	VALUE self;
 } t_tmir;
 
+static size_t
+pg_tmir_memsize( const void *_this )
+{
+	const t_tmir *this = (const t_tmir *)_this;
+	return sizeof(*this);
+}
+
+static void
+pg_tmir_compact( void *_this )
+{
+	t_tmir *this = (t_tmir *)_this;
+	pg_typemap_compact(&this->typemap);
+	pg_gc_location(this->self);
+}
+
+static const rb_data_type_t pg_tmir_type = {
+	"PG::TypeMapInRuby",
+	{
+		pg_typemap_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_tmir_memsize,
+		pg_compact_callback(pg_tmir_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 /*
  * call-seq:
@@ -34,33 +61,37 @@ typedef struct {
 static VALUE
 pg_tmir_fit_to_result( VALUE self, VALUE result )
 {
-	t_tmir *this = DATA_PTR( self );
+	t_tmir *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 	t_typemap *p_new_typemap;
 	VALUE sub_typemap;
 	VALUE new_typemap;
 
 	if( rb_respond_to(self, s_id_fit_to_result) ){
+		t_typemap *tm;
+		UNUSED(tm);
 		new_typemap = rb_funcall( self, s_id_fit_to_result, 1, result );
 
 		if ( !rb_obj_is_kind_of(new_typemap, rb_cTypeMap) ) {
+			/* TypedData_Get_Struct() raises "wrong argument type", which is misleading,
+			* so we better raise our own message */
 			rb_raise( rb_eTypeError, "wrong return type from fit_to_result: %s expected kind of PG::TypeMap",
 					rb_obj_classname( new_typemap ) );
 		}
-		Check_Type( new_typemap, T_DATA );
+		TypedData_Get_Struct(new_typemap, t_typemap, &pg_typemap_type, tm);
 	} else {
 		new_typemap = self;
 	}
 
-	/* Ensure that the default type map fits equaly. */
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	sub_typemap = default_tm->funcs.fit_to_result( this->typemap.default_typemap, result );
 
 	if( sub_typemap != this->typemap.default_typemap ){
 		new_typemap = rb_obj_dup( new_typemap );
 	}
 
-	p_new_typemap = DATA_PTR(new_typemap);
+	p_new_typemap = RTYPEDDATA_DATA(new_typemap);
 	p_new_typemap->default_typemap = sub_typemap;
 	return new_typemap;
 }
@@ -95,8 +126,8 @@ pg_tmir_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 static VALUE
 pg_tmir_typecast_result_value( VALUE self, VALUE result, VALUE tuple, VALUE field )
 {
-	t_tmir *this = DATA_PTR( self );
-	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	t_tmir *this = RTYPEDDATA_DATA( self );
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	return default_tm->funcs.typecast_result_value( default_tm, result, NUM2INT(tuple), NUM2INT(field) );
 }
 
@@ -113,15 +144,15 @@ pg_tmir_typecast_result_value( VALUE self, VALUE result, VALUE tuple, VALUE fiel
 static VALUE
 pg_tmir_fit_to_query( VALUE self, VALUE params )
 {
-	t_tmir *this = DATA_PTR( self );
+	t_tmir *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 
 	if( rb_respond_to(self, s_id_fit_to_query) ){
 		rb_funcall( self, s_id_fit_to_query, 1, params );
 	}
 
-	/* Ensure that the default type map fits equaly. */
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
 
 	return self;
@@ -137,7 +168,7 @@ pg_tmir_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 	if ( NIL_P(coder) ){
 		return NULL;
 	} else if( rb_obj_is_kind_of(coder, rb_cPG_Coder) ) {
-		return DATA_PTR(coder);
+		return RTYPEDDATA_DATA(coder);
 	} else {
 		rb_raise( rb_eTypeError, "wrong return type from typecast_query_param: %s expected nil or kind of PG::Coder",
 				rb_obj_classname( coder ) );
@@ -161,8 +192,8 @@ pg_tmir_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 static VALUE
 pg_tmir_typecast_query_param( VALUE self, VALUE param_value, VALUE field )
 {
-	t_tmir *this = DATA_PTR( self );
-	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	t_tmir *this = RTYPEDDATA_DATA( self );
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	t_pg_coder *p_coder = default_tm->funcs.typecast_query_param( default_tm, param_value, NUM2INT(field) );
 
 	return p_coder ? p_coder->coder_obj : Qnil;
@@ -186,7 +217,7 @@ static VALUE pg_tmir_fit_to_copy_get_dummy( VALUE self ){}
 static int
 pg_tmir_fit_to_copy_get( VALUE self )
 {
-	t_tmir *this = DATA_PTR( self );
+	t_tmir *this = RTYPEDDATA_DATA( self );
 	t_typemap *default_tm;
 	VALUE num_columns = INT2NUM(0);
 
@@ -198,8 +229,8 @@ pg_tmir_fit_to_copy_get( VALUE self )
 		rb_raise( rb_eTypeError, "wrong return type from fit_to_copy_get: %s expected kind of Integer",
 				rb_obj_classname( num_columns ) );
 	}
-	/* Ensure that the default type map fits equaly. */
-	default_tm = DATA_PTR( this->typemap.default_typemap );
+	/* Ensure that the default type map fits equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	default_tm->funcs.fit_to_copy_get( this->typemap.default_typemap );
 
 	return NUM2INT(num_columns);;
@@ -239,8 +270,8 @@ pg_tmir_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format
 static VALUE
 pg_tmir_typecast_copy_get( VALUE self, VALUE field_str, VALUE fieldno, VALUE format, VALUE enc )
 {
-	t_tmir *this = DATA_PTR( self );
-	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	t_tmir *this = RTYPEDDATA_DATA( self );
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
 	int enc_idx = rb_to_encoding_index( enc );
 
 	return default_tm->funcs.typecast_copy_get( default_tm, field_str, NUM2INT(fieldno), NUM2INT(format), enc_idx );
@@ -252,7 +283,7 @@ pg_tmir_s_allocate( VALUE klass )
 	t_tmir *this;
 	VALUE self;
 
-	self = Data_Make_Struct( klass, t_tmir, NULL, -1, this );
+	self = TypedData_Make_Struct( klass, t_tmir, &pg_tmir_type, this );
 
 	this->typemap.funcs.fit_to_result = pg_tmir_fit_to_result;
 	this->typemap.funcs.fit_to_query = pg_tmir_fit_to_query;

data/ext/pg_util.c

@@ -91,7 +91,7 @@ base64_decode( char *out, const char *in, unsigned int len)
 			*out_ptr++ = (b << 4) | (c >> 2);
 			*out_ptr++ = (c << 6) | d;
 		} else if (in_ptr < iend_ptr){
-			a = b = c = d = 0xff;
+			b = c = d = 0xff;
 			while ((a = base64_decode_table[*in_ptr++]) == 0xff && in_ptr < iend_ptr) {}
 			if (in_ptr < iend_ptr){
 				while ((b = base64_decode_table[*in_ptr++]) == 0xff && in_ptr < iend_ptr) {}
@@ -116,7 +116,7 @@ base64_decode( char *out, const char *in, unsigned int len)
 	}
 
 
-	return (char*)out_ptr - out;
+	return (int)((char*)out_ptr - out);
 }
 
 /*

data/lib/pg/basic_type_map_based_on_result.rb

@@ -0,0 +1,47 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'pg' unless defined?( PG )
+
+# Simple set of rules for type casting common PostgreSQL types from Ruby
+# to PostgreSQL.
+#
+# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
+# PostgreSQL's +pg_type+ table in PG::BasicTypeMapBasedOnResult.new .
+#
+# This class works equal to PG::BasicTypeMapForResults, but does not define decoders for
+# the given result OIDs, but encoders. So it can be used to type cast field values based on
+# the type OID retrieved by a separate SQL query.
+#
+# PG::TypeMapByOid#build_column_map(result) can be used to generate a result independent
+# PG::TypeMapByColumn type map, which can subsequently be used to cast query bind parameters
+# or #put_copy_data fields.
+#
+# Example:
+#   conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, ai INT[])" )
+#
+#   # Retrieve table OIDs per empty result set.
+#   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
+#   # Build a type map for common ruby to database type encoders.
+#   btm = PG::BasicTypeMapBasedOnResult.new(conn)
+#   # Build a PG::TypeMapByColumn with encoders suitable for copytable.
+#   tm = btm.build_column_map( res )
+#   row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|
+#     conn.put_copy_data ['a', 123, [5,4,3]]
+#   end
+# This inserts a single row into copytable with type casts from ruby to
+# database types.
+class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
+	include PG::BasicTypeRegistry::Checker
+
+	def initialize(connection_or_coder_maps, registry: nil)
+		@coder_maps = build_coder_maps(connection_or_coder_maps, registry: registry)
+
+		# Populate TypeMapByOid hash with encoders
+		@coder_maps.each_format(:encoder).flat_map{|f| f.coders }.each do |coder|
+			add_coder(coder)
+		end
+	end
+end

data/lib/pg/basic_type_map_for_queries.rb

@@ -0,0 +1,193 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'pg' unless defined?( PG )
+
+# Simple set of rules for type casting common Ruby types to PostgreSQL.
+#
+# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
+# PostgreSQL's pg_type table in PG::BasicTypeMapForQueries.new .
+#
+# Query params are type casted based on the class of the given value.
+#
+# Higher level libraries will most likely not make use of this class, but use their
+# own derivation of PG::TypeMapByClass or another set of rules to choose suitable
+# encoders and decoders for the values to be sent.
+#
+# Example:
+#   conn = PG::Connection.new
+#   # Assign a default ruleset for type casts of input and output values.
+#   conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
+#   # Execute a query. The Integer param value is typecasted internally by PG::BinaryEncoder::Int8.
+#   # The format of the parameter is set to 0 (text) and the OID of this parameter is set to 20 (int8).
+#   res = conn.exec_params( "SELECT $1", [5] )
+class PG::BasicTypeMapForQueries < PG::TypeMapByClass
+	# Helper class for submission of binary strings into bytea columns.
+	#
+	# Since PG::BasicTypeMapForQueries chooses the encoder to be used by the class of the submitted value,
+	# it's necessary to send binary strings as BinaryData.
+	# That way they're distinct from text strings.
+	# Please note however that PG::BasicTypeMapForResults delivers bytea columns as plain String
+	# with binary encoding.
+	#
+	#   conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
+	#   conn.exec("CREATE TEMP TABLE test (data bytea)")
+	#   bd = PG::BasicTypeMapForQueries::BinaryData.new("ab\xff\0cd")
+	#   conn.exec_params("INSERT INTO test (data) VALUES ($1)", [bd])
+	class BinaryData < String
+	end
+
+	class UndefinedEncoder < RuntimeError
+	end
+
+	include PG::BasicTypeRegistry::Checker
+
+	# Create a new type map for query submission
+	#
+	# Options:
+	# * +registry+: Custom type registry, nil for default global registry
+	# * +if_undefined+: Optional +Proc+ object which is called, if no type for an parameter class is not defined in the registry.
+	def initialize(connection_or_coder_maps, registry: nil, if_undefined: nil)
+		@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 || proc { |oid_name, format|
+			raise UndefinedEncoder, "no encoder defined for type #{oid_name.inspect} format #{format}"
+		}
+		init_encoders
+	end
+
+	# Change the mechanism that is used to encode ruby array values
+	#
+	# Possible values:
+	# * +:array+ : Encode the ruby array as a PostgreSQL array.
+	#   The array element type is inferred from the class of the first array element. This is the default.
+	# * +:json+ : Encode the ruby array as a JSON document.
+	# * +:record+ : Encode the ruby array as a composite type row.
+	# * <code>"_type"</code> : Encode the ruby array as a particular PostgreSQL type.
+	#   All PostgreSQL array types are supported.
+	#   If there's an encoder registered for the elements +type+, it will be used.
+	#   Otherwise a string conversion (by +value.to_s+) is done.
+	def encode_array_as=(pg_type)
+		case pg_type
+			when :array
+			when :json
+			when :record
+			when /\A_/
+			else
+				raise ArgumentError, "invalid pg_type #{pg_type.inspect}"
+		end
+
+		@encode_array_as = pg_type
+
+		init_encoders
+	end
+
+	attr_reader :encode_array_as
+
+	private
+
+	def init_encoders
+		coders.each { |kl, c| self[kl] = nil } # Clear type map
+		populate_encoder_list
+		@textarray_encoder = coder_by_name(0, :encoder, '_text')
+	end
+
+	def coder_by_name(format, direction, name)
+		check_format_and_direction(format, direction)
+		@coder_maps.map_for(format, direction).coder_by_name(name)
+	end
+
+	def undefined(name, format)
+		@if_undefined.call(name, format)
+	end
+
+	def populate_encoder_list
+		DEFAULT_TYPE_MAP.each do |klass, selector|
+			if Array === selector
+				format, name, oid_name = selector
+				coder = coder_by_name(format, :encoder, name).dup
+				if coder
+					if oid_name
+						oid_coder = coder_by_name(format, :encoder, oid_name)
+						if oid_coder
+							coder.oid = oid_coder.oid
+						else
+							undefined(oid_name, format)
+						end
+					else
+						coder.oid = 0
+					end
+					self[klass] = coder
+				else
+					undefined(name, format)
+				end
+			else
+
+				case @encode_array_as
+					when :array
+						self[klass] = selector
+					when :json
+						self[klass] = PG::TextEncoder::JSON.new
+					when :record
+						self[klass] = PG::TextEncoder::Record.new type_map: self
+					when /\A_/
+						coder = coder_by_name(0, :encoder, @encode_array_as)
+						if coder
+							self[klass] = coder
+						else
+							undefined(@encode_array_as, format)
+						end
+					else
+						raise ArgumentError, "invalid pg_type #{@encode_array_as.inspect}"
+				end
+			end
+		end
+	end
+
+	def array_encoders_by_klass
+		DEFAULT_ARRAY_TYPE_MAP.inject({}) do |h, (klass, (format, name))|
+			h[klass] = coder_by_name(format, :encoder, name)
+			h
+		end
+	end
+
+	def get_array_type(value)
+		elem = value
+		while elem.kind_of?(Array)
+			elem = elem.first
+		end
+		@array_encoders_by_klass[elem.class] ||
+				elem.class.ancestors.lazy.map{|ancestor| @array_encoders_by_klass[ancestor] }.find{|a| a } ||
+				@textarray_encoder
+	end
+
+	DEFAULT_TYPE_MAP = {
+		TrueClass => [1, 'bool', 'bool'],
+		FalseClass => [1, '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'],
+		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.
+		IPAddr => [0, 'inet'],
+		Hash => [0, 'json'],
+		Array => :get_array_type,
+		BinaryData => [1, 'bytea'],
+	}
+
+	DEFAULT_ARRAY_TYPE_MAP = {
+		TrueClass => [0, '_bool'],
+		FalseClass => [0, '_bool'],
+		Integer => [0, '_int8'],
+		String => [0, '_text'],
+		Float => [0, '_float8'],
+		BigDecimal => [0, '_numeric'],
+		Time => [0, '_timestamptz'],
+		IPAddr => [0, '_inet'],
+	}
+
+end

data/lib/pg/basic_type_map_for_results.rb

@@ -0,0 +1,81 @@
+# -*- ruby -*-
+# frozen_string_literal: true
+
+require 'pg' unless defined?( PG )
+
+# Simple set of rules for type casting common PostgreSQL types to Ruby.
+#
+# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
+# PostgreSQL's +pg_type+ table in PG::BasicTypeMapForResults.new .
+#
+# Result values are type casted based on the type OID of the given result column.
+#
+# Higher level libraries will most likely not make use of this class, but use their
+# own set of rules to choose suitable encoders and decoders.
+#
+# Example:
+#   conn = PG::Connection.new
+#   # Assign a default ruleset for type casts of output values.
+#   conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn)
+#   # Execute a query.
+#   res = conn.exec_params( "SELECT $1::INT", ['5'] )
+#   # Retrieve and cast the result value. Value format is 0 (text) and OID is 20. Therefore typecasting
+#   # is done by PG::TextDecoder::Integer internally for all value retrieval methods.
+#   res.values  # => [[5]]
+#
+# PG::TypeMapByOid#build_column_map(result) can be used to generate
+# a result independent PG::TypeMapByColumn type map, which can subsequently be used
+# to cast #get_copy_data fields:
+#
+# For the following table:
+#   conn.exec( "CREATE TABLE copytable AS VALUES('a', 123, '{5,4,3}'::INT[])" )
+#
+#   # Retrieve table OIDs per empty result set.
+#   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
+#   # Build a type map for common database to ruby type decoders.
+#   btm = PG::BasicTypeMapForResults.new(conn)
+#   # Build a PG::TypeMapByColumn with decoders suitable for copytable.
+#   tm = btm.build_column_map( res )
+#   row_decoder = PG::TextDecoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable TO STDOUT", row_decoder ) do |res|
+#     while row=conn.get_copy_data
+#       p row
+#     end
+#   end
+# This prints the rows with type casted columns:
+#   ["a", 123, [5, 4, 3]]
+#
+# See also PG::BasicTypeMapBasedOnResult for the encoder direction and PG::BasicTypeRegistry for the definition of additional types.
+class PG::BasicTypeMapForResults < PG::TypeMapByOid
+	include PG::BasicTypeRegistry::Checker
+
+	class WarningTypeMap < PG::TypeMapInRuby
+		def initialize(typenames)
+			@already_warned = Hash.new{|h, k| h[k] = {} }
+			@typenames_by_oid = typenames
+		end
+
+		def typecast_result_value(result, _tuple, field)
+			format = result.fformat(field)
+			oid = result.ftype(field)
+			unless @already_warned[format][oid]
+				warn "Warning: no type cast defined for type #{@typenames_by_oid[oid].inspect} format #{format} with oid #{oid}. Please cast this type explicitly to TEXT to be safe for future changes."
+				 @already_warned[format][oid] = true
+			end
+			super
+		end
+	end
+
+	def initialize(connection_or_coder_maps, registry: nil)
+		@coder_maps = build_coder_maps(connection_or_coder_maps, registry: registry)
+
+		# Populate TypeMapByOid hash with decoders
+		@coder_maps.each_format(:decoder).flat_map{|f| f.coders }.each do |coder|
+			add_coder(coder)
+		end
+
+		typenames = @coder_maps.typenames_by_oid
+		self.default_type_map = WarningTypeMap.new(typenames)
+	end
+end