pg 1.1.4 → 1.5.3

data/ext/pg_type_map_by_oid.c

@@ -1,6 +1,6 @@
 /*
  * pg_type_map_by_oid.c - PG::TypeMapByOid class extension
- * $Id: pg_type_map_by_oid.c,v c99d26015e3c 2014/12/12 20:58:25 lars $
+ * $Id$
  *
  */
 
@@ -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++)
 	{
@@ -110,21 +110,21 @@ pg_tmbo_result_value(t_typemap *p_typemap, VALUE result, int tuple, int field)
 		char * val = PQgetvalue( p_result->pgresult, tuple, field );
 		int len = PQgetlength( p_result->pgresult, tuple, field );
 		t_pg_coder_dec_func dec_func = pg_coder_dec_func( p_coder, format );
-		return dec_func( p_coder, val, len, tuple, field, ENCODING_GET(result) );
+		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 | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
 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;
@@ -179,11 +212,11 @@ pg_tmbo_s_allocate( VALUE klass )
 	this->typemap.funcs.typecast_result_value = pg_tmbo_result_value;
 	this->typemap.funcs.typecast_query_param = pg_typemap_typecast_query_param;
 	this->typemap.funcs.typecast_copy_get = pg_typemap_typecast_copy_get;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	this->max_rows_for_online_lookup = 10;
 
 	for( i=0; i<2; i++){
-		this->format[i].oid_to_coder = rb_hash_new();
+		RB_OBJ_WRITE(self, &this->format[i].oid_to_coder, rb_hash_new());
 	}
 
 	return self;
@@ -205,15 +238,12 @@ 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);
+	rb_check_frozen(self);
+	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,10 +273,11 @@ 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;
 
+	rb_check_frozen(self);
 	if( i_format < 0 || i_format > 1 )
 		rb_raise(rb_eArgError, "invalid format code %d", i_format);
 
@@ -269,7 +300,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 +319,8 @@ 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 );
+	rb_check_frozen(self);
 	this->max_rows_for_online_lookup = NUM2INT(value);
 	return value;
 }
@@ -300,7 +332,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);
 }
 
@@ -309,13 +341,13 @@ pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
  *    typemap.build_column_map( result )
  *
  * This builds a PG::TypeMapByColumn that fits to the given PG::Result object
- * based on it's type OIDs.
+ * based on it's type OIDs and binary/text format.
  *
  */
 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)",
@@ -327,7 +359,7 @@ pg_tmbo_build_column_map( VALUE self, VALUE result )
 
 
 void
-init_pg_type_map_by_oid()
+init_pg_type_map_by_oid(void)
 {
 	s_id_decode = rb_intern("decode");
 
@@ -351,5 +383,6 @@ init_pg_type_map_by_oid()
 	rb_define_method( rb_cTypeMapByOid, "max_rows_for_online_lookup=", pg_tmbo_max_rows_for_online_lookup_set, 1 );
 	rb_define_method( rb_cTypeMapByOid, "max_rows_for_online_lookup", pg_tmbo_max_rows_for_online_lookup_get, 0 );
 	rb_define_method( rb_cTypeMapByOid, "build_column_map", pg_tmbo_build_column_map, 1 );
+	/* rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable"); */
 	rb_include_module( rb_cTypeMapByOid, rb_mDefaultTypeMappable );
 }

data/ext/pg_type_map_in_ruby.c

@@ -1,6 +1,6 @@
 /*
  * pg_type_map_in_ruby.c - PG::TypeMapInRuby class extension
- * $Id: pg_type_map_in_ruby.c,v 3d89d3aae4fd 2015/01/05 16:19:41 kanis $
+ * $Id$
  *
  */
 
@@ -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 | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
+};
 
 /*
  * 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;
@@ -179,6 +210,9 @@ pg_tmir_typecast_query_param( VALUE self, VALUE param_value, VALUE field )
  * This method is called, when a type map is used for decoding copy data,
  * before the value is casted.
  *
+ * Should return the expected number of columns or 0 if the number of columns is unknown.
+ * This number is only used for memory pre-allocation.
+ *
  */
 static VALUE pg_tmir_fit_to_copy_get_dummy( VALUE self ){}
 #endif
@@ -186,7 +220,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 +232,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 +273,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 +286,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;
@@ -260,7 +294,7 @@ pg_tmir_s_allocate( VALUE klass )
 	this->typemap.funcs.typecast_result_value = pg_tmir_result_value;
 	this->typemap.funcs.typecast_query_param = pg_tmir_query_param;
 	this->typemap.funcs.typecast_copy_get = pg_tmir_copy_get;
-	this->typemap.default_typemap = pg_typemap_all_strings;
+	RB_OBJ_WRITE(self, &this->typemap.default_typemap, pg_typemap_all_strings);
 	this->self = self;
 
 	return self;
@@ -268,7 +302,7 @@ pg_tmir_s_allocate( VALUE klass )
 
 
 void
-init_pg_type_map_in_ruby()
+init_pg_type_map_in_ruby(void)
 {
 	s_id_fit_to_result = rb_intern("fit_to_result");
 	s_id_fit_to_query = rb_intern("fit_to_query");

data/ext/{util.c → pg_util.c}

@@ -1,11 +1,11 @@
 /*
- * util.c - Utils for ruby-pg
- * $Id: util.c,v fc1c4deb1398 2018/06/25 12:02:09 kanis $
+ * pg_util.c - Utils for ruby-pg
+ * $Id$
  *
  */
 
 #include "pg.h"
-#include "util.h"
+#include "pg_util.h"
 
 static const char base64_encode_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
@@ -22,12 +22,12 @@ base64_encode( char *out, const char *in, int len)
 	int part_len = len % 3;
 
 	if( part_len > 0 ){
-		long byte2 = part_len > 2 ? *--in_ptr : 0;
+		long byte2 = 0;
 		long byte1 = part_len > 1 ? *--in_ptr : 0;
 		long byte0 = *--in_ptr;
 		long triple = (byte0 << 16) + (byte1 << 8) + byte2;
 
-		*--out_ptr = part_len > 2 ? base64_encode_table[(triple >> 0 * 6) & 0x3F] : '=';
+		*--out_ptr = '=';
 		*--out_ptr = part_len > 1 ? base64_encode_table[(triple >> 1 * 6) & 0x3F] : '=';
 		*--out_ptr = base64_encode_table[(triple >> 2 * 6) & 0x3F];
 		*--out_ptr = base64_encode_table[(triple >> 3 * 6) & 0x3F];
@@ -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,67 @@
+# -*- 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 using text format.
+#
+# Very similar with binary format:
+#
+#   conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, blob bytea, created_at timestamp)" )
+#   # Retrieve table OIDs per empty result set in binary format.
+#   res = conn.exec_params( "SELECT * FROM copytable LIMIT 0", [], 1 )
+#   # 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::BinaryEncoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable FROM STDIN WITH (FORMAT binary)", row_encoder ) do |res|
+#     conn.put_copy_data ['a', 123, "\xff\x00".b, Time.now]
+#   end
+#
+# This inserts a single row into copytable with type casts from ruby to
+# database types using binary copy and value format.
+# Binary COPY is faster than text format but less portable and less readable and pg offers fewer en-/decoders of 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