pg 1.3.0.rc2-x64-mingw-ucrt

data/ext/pg_type_map_by_oid.c

@@ -0,0 +1,385 @@
+/*
+ * pg_type_map_by_oid.c - PG::TypeMapByOid class extension
+ * $Id$
+ *
+ */
+
+#include "pg.h"
+
+static VALUE rb_cTypeMapByOid;
+static ID s_id_decode;
+
+typedef struct {
+	t_typemap typemap;
+	int max_rows_for_online_lookup;
+
+	struct pg_tmbo_converter {
+		VALUE oid_to_coder;
+
+		struct pg_tmbo_oid_cache_entry {
+			Oid oid;
+			t_pg_coder *p_coder;
+		} cache_row[0x100];
+	} format[2];
+} t_tmbo;
+
+static VALUE pg_tmbo_s_allocate( VALUE klass );
+
+
+/*
+ * We use the OID's minor 8 Bits as index to a 256 entry cache. This avoids full ruby hash lookups
+ * for each value in most cases.
+ */
+#define CACHE_LOOKUP(this, form, oid) ( &this->format[(form)].cache_row[(oid) & 0xff] )
+
+static t_pg_coder *
+pg_tmbo_lookup_oid(t_tmbo *this, int format, Oid oid)
+{
+	t_pg_coder *conv;
+	struct pg_tmbo_oid_cache_entry *p_ce;
+
+	p_ce = CACHE_LOOKUP(this, format, oid);
+
+	/* Has the entry the expected OID and is it a non empty entry? */
+	if( p_ce->oid == oid && (oid || p_ce->p_coder) ) {
+		conv = p_ce->p_coder;
+	} 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 : RTYPEDDATA_DATA(obj);
+		/* Write the retrieved coder to the cache */
+		p_ce->oid = oid;
+		p_ce->p_coder = conv;
+	}
+	return conv;
+}
+
+/* Build a TypeMapByColumn that fits to the given result */
+static VALUE
+pg_tmbo_build_type_map_for_result2( t_tmbo *this, PGresult *pgresult )
+{
+	t_tmbc *p_colmap;
+	int i;
+	VALUE colmap;
+	int nfields = PQnfields( pgresult );
+
+	p_colmap = xmalloc(sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * nfields);
+	/* Set nfields to 0 at first, so that GC mark function doesn't access uninitialized memory. */
+	p_colmap->nfields = 0;
+	p_colmap->typemap.funcs = pg_tmbc_funcs;
+	p_colmap->typemap.default_typemap = pg_typemap_all_strings;
+
+	colmap = pg_tmbc_allocate();
+	RTYPEDDATA_DATA(colmap) = p_colmap;
+
+	for(i=0; i<nfields; i++)
+	{
+		int format = PQfformat(pgresult, i);
+
+		if( format < 0 || format > 1 )
+			rb_raise(rb_eArgError, "result field %d has unsupported format code %d", i+1, format);
+
+		p_colmap->convs[i].cconv = pg_tmbo_lookup_oid( this, format, PQftype(pgresult, i) );
+	}
+
+	p_colmap->nfields = nfields;
+
+	return colmap;
+}
+
+static VALUE
+pg_tmbo_result_value(t_typemap *p_typemap, VALUE result, int tuple, int field)
+{
+	int format;
+	t_pg_coder *p_coder;
+	t_pg_result *p_result = pgresult_get_this(result);
+	t_tmbo *this = (t_tmbo*) p_typemap;
+	t_typemap *default_tm;
+
+	if (PQgetisnull(p_result->pgresult, tuple, field)) {
+		return Qnil;
+	}
+
+	format = PQfformat( p_result->pgresult, field );
+
+	if( format < 0 || format > 1 )
+		rb_raise(rb_eArgError, "result field %d has unsupported format code %d", field+1, format);
+
+	p_coder = pg_tmbo_lookup_oid( this, format, PQftype(p_result->pgresult, field) );
+	if( p_coder ){
+		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, p_result->enc_idx );
+	}
+
+	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 = RTYPEDDATA_DATA( self );
+	PGresult *pgresult = pgresult_get( result );
+
+	/* 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 ){
+		/* Do a hash lookup for each result value in pg_tmbc_result_value() */
+
+		/* Did the default type return the same object ? */
+		if( sub_typemap == this->typemap.default_typemap ){
+			return self;
+		} else {
+			/* 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 = RTYPEDDATA_DATA(new_typemap);
+			*p_new_typemap = *this;
+			p_new_typemap->typemap.default_typemap = sub_typemap;
+			return new_typemap;
+		}
+	}else{
+		/* Build a new TypeMapByColumn that fits to the given result and
+		 * uses a fast array lookup.
+		 */
+		VALUE new_typemap = pg_tmbo_build_type_map_for_result2( this, pgresult );
+		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( void *_this )
+{
+	t_tmbo *this = (t_tmbo *)_this;
+	int i;
+
+	pg_typemap_mark(&this->typemap);
+	for( i=0; i<2; i++){
+		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 )
+{
+	t_tmbo *this;
+	VALUE self;
+	int i;
+
+	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;
+	this->typemap.funcs.fit_to_copy_get = pg_typemap_fit_to_copy_get;
+	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;
+	this->max_rows_for_online_lookup = 10;
+
+	for( i=0; i<2; i++){
+		this->format[i].oid_to_coder = rb_hash_new();
+	}
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *    typemap.add_coder( coder )
+ *
+ * Assigns a new PG::Coder object to the type map. The decoder
+ * is registered for type casts based on it's PG::Coder#oid and
+ * PG::Coder#format attributes.
+ *
+ * Later changes of the oid or format code within the coder object
+ * will have no effect to the type map.
+ *
+ */
+static VALUE
+pg_tmbo_add_coder( VALUE self, VALUE coder )
+{
+	VALUE hash;
+	t_tmbo *this = RTYPEDDATA_DATA( self );
+	t_pg_coder *p_coder;
+	struct pg_tmbo_oid_cache_entry *p_ce;
+
+	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);
+
+	/* Update cache entry */
+	p_ce = CACHE_LOOKUP(this, p_coder->format, p_coder->oid);
+	p_ce->oid = p_coder->oid;
+	p_ce->p_coder = p_coder;
+	/* Write coder into the hash of the given format */
+	hash = this->format[p_coder->format].oid_to_coder;
+	rb_hash_aset( hash, UINT2NUM(p_coder->oid), coder);
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *    typemap.rm_coder( format, oid )
+ *
+ * Removes a PG::Coder object from the type map based on the given
+ * oid and format codes.
+ *
+ * Returns the removed coder object.
+ */
+static VALUE
+pg_tmbo_rm_coder( VALUE self, VALUE format, VALUE oid )
+{
+	VALUE hash;
+	VALUE coder;
+	t_tmbo *this = RTYPEDDATA_DATA( self );
+	int i_format = NUM2INT(format);
+	struct pg_tmbo_oid_cache_entry *p_ce;
+
+	if( i_format < 0 || i_format > 1 )
+		rb_raise(rb_eArgError, "invalid format code %d", i_format);
+
+	/* Mark the cache entry as empty */
+	p_ce = CACHE_LOOKUP(this, i_format, NUM2UINT(oid));
+	p_ce->oid = 0;
+	p_ce->p_coder = NULL;
+	hash = this->format[i_format].oid_to_coder;
+	coder = rb_hash_delete( hash, oid );
+
+	return coder;
+}
+
+/*
+ * call-seq:
+ *    typemap.coders -> Array
+ *
+ * Array of all assigned PG::Coder objects.
+ */
+static VALUE
+pg_tmbo_coders( VALUE self )
+{
+	t_tmbo *this = RTYPEDDATA_DATA( self );
+
+	return rb_ary_concat(
+			rb_funcall(this->format[0].oid_to_coder, rb_intern("values"), 0),
+			rb_funcall(this->format[1].oid_to_coder, rb_intern("values"), 0));
+}
+
+/*
+ * call-seq:
+ *    typemap.max_rows_for_online_lookup = number
+ *
+ * Threshold for doing Hash lookups versus creation of a dedicated PG::TypeMapByColumn.
+ * The type map will do Hash lookups for each result value, if the number of rows
+ * is below or equal +number+.
+ *
+ */
+static VALUE
+pg_tmbo_max_rows_for_online_lookup_set( VALUE self, VALUE value )
+{
+	t_tmbo *this = RTYPEDDATA_DATA( self );
+	this->max_rows_for_online_lookup = NUM2INT(value);
+	return value;
+}
+
+/*
+ * call-seq:
+ *    typemap.max_rows_for_online_lookup -> Integer
+ */
+static VALUE
+pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
+{
+	t_tmbo *this = RTYPEDDATA_DATA( self );
+	return INT2NUM(this->max_rows_for_online_lookup);
+}
+
+/*
+ * call-seq:
+ *    typemap.build_column_map( result )
+ *
+ * This builds a PG::TypeMapByColumn that fits to the given PG::Result object
+ * based on it's type OIDs.
+ *
+ */
+static VALUE
+pg_tmbo_build_column_map( VALUE self, VALUE result )
+{
+	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)",
+				rb_obj_classname( result ) );
+	}
+
+	return pg_tmbo_build_type_map_for_result2( this, pgresult_get(result) );
+}
+
+
+void
+init_pg_type_map_by_oid()
+{
+	s_id_decode = rb_intern("decode");
+
+	/*
+	 * Document-class: PG::TypeMapByOid < PG::TypeMap
+	 *
+	 * This type map casts values based on the type OID of the given column
+	 * in the result set.
+	 *
+	 * This type map is only suitable to cast values from PG::Result objects.
+	 * Therefore only decoders might be assigned by the #add_coder method.
+	 *
+	 * Fields with no match to any of the registered type OID / format combination
+	 * are forwarded to the #default_type_map .
+	 */
+	rb_cTypeMapByOid = rb_define_class_under( rb_mPG, "TypeMapByOid", rb_cTypeMap );
+	rb_define_alloc_func( rb_cTypeMapByOid, pg_tmbo_s_allocate );
+	rb_define_method( rb_cTypeMapByOid, "add_coder", pg_tmbo_add_coder, 1 );
+	rb_define_method( rb_cTypeMapByOid, "rm_coder", pg_tmbo_rm_coder, 2 );
+	rb_define_method( rb_cTypeMapByOid, "coders", pg_tmbo_coders, 0 );
+	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

@@ -0,0 +1,330 @@
+/*
+ * pg_type_map_in_ruby.c - PG::TypeMapInRuby class extension
+ * $Id$
+ *
+ */
+
+#include "pg.h"
+
+VALUE rb_cTypeMapInRuby;
+static VALUE s_id_fit_to_result;
+static VALUE s_id_fit_to_query;
+static VALUE s_id_fit_to_copy_get;
+static VALUE s_id_typecast_result_value;
+static VALUE s_id_typecast_query_param;
+static VALUE s_id_typecast_copy_get;
+
+typedef struct {
+	t_typemap typemap;
+	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:
+ *    typemap.fit_to_result( result )
+ *
+ * Check that the type map fits to the result.
+ *
+ * This method is called, when a type map is assigned to a result.
+ * It must return a PG::TypeMap object or raise an Exception.
+ * This can be +self+ or some other type map that fits to the result.
+ *
+ */
+static VALUE
+pg_tmir_fit_to_result( VALUE self, VALUE result )
+{
+	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 ) );
+		}
+		TypedData_Get_Struct(new_typemap, t_typemap, &pg_typemap_type, tm);
+	} else {
+		new_typemap = self;
+	}
+
+	/* 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 = RTYPEDDATA_DATA(new_typemap);
+	p_new_typemap->default_typemap = sub_typemap;
+	return new_typemap;
+}
+
+static VALUE
+pg_tmir_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
+{
+	t_tmir *this = (t_tmir *) p_typemap;
+
+	return rb_funcall( this->self, s_id_typecast_result_value, 3, result, INT2NUM(tuple), INT2NUM(field) );
+}
+
+/*
+ * call-seq:
+ *    typemap.typecast_result_value( result, tuple, field )
+ *
+ * Retrieve and cast a field of the given result.
+ *
+ * This method implementation uses the #default_type_map to get the
+ * field value. It can be derived to change this behaviour.
+ *
+ * Parameters:
+ * * +result+ : The PG::Result received from the database.
+ * * +tuple+ : The row number to retrieve.
+ * * +field+ : The column number to retrieve.
+ *
+ * Note: Calling any value retrieving methods of +result+ will result
+ * in an (endless) recursion. Instead super() can be used to retrieve
+ * the value using the default_typemap.
+ *
+ */
+static VALUE
+pg_tmir_typecast_result_value( VALUE self, VALUE result, VALUE tuple, VALUE field )
+{
+	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) );
+}
+
+/*
+ * call-seq:
+ *    typemap.fit_to_query( params )
+ *
+ * Check that the type map fits to the given user values.
+ *
+ * This method is called, when a type map is used for sending a query
+ * and for encoding of copy data, before the value is casted.
+ *
+ */
+static VALUE
+pg_tmir_fit_to_query( VALUE self, VALUE params )
+{
+	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 equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
+
+	return self;
+}
+
+static t_pg_coder *
+pg_tmir_query_param( t_typemap *p_typemap, VALUE param_value, int field )
+{
+	t_tmir *this = (t_tmir *) p_typemap;
+
+	VALUE coder = rb_funcall( this->self, s_id_typecast_query_param, 2, param_value, INT2NUM(field) );
+
+	if ( NIL_P(coder) ){
+		return NULL;
+	} else if( rb_obj_is_kind_of(coder, rb_cPG_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 ) );
+	}
+}
+
+/*
+ * call-seq:
+ *    typemap.typecast_query_param( param_value, field )
+ *
+ * Cast a field string for transmission to the server.
+ *
+ * This method implementation uses the #default_type_map to cast param_value.
+ * It can be derived to change this behaviour.
+ *
+ * Parameters:
+ * * +param_value+ : The value from the user.
+ * * +field+ : The field number from left to right.
+ *
+ */
+static VALUE
+pg_tmir_typecast_query_param( VALUE self, VALUE param_value, VALUE field )
+{
+	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;
+}
+
+/* This is to fool rdoc's C parser */
+#if 0
+/*
+ * call-seq:
+ *    typemap.fit_to_copy_get()
+ *
+ * Check that the type map can be used for PG::Connection#get_copy_data.
+ *
+ * This method is called, when a type map is used for decoding copy data,
+ * before the value is casted.
+ *
+ */
+static VALUE pg_tmir_fit_to_copy_get_dummy( VALUE self ){}
+#endif
+
+static int
+pg_tmir_fit_to_copy_get( VALUE self )
+{
+	t_tmir *this = RTYPEDDATA_DATA( self );
+	t_typemap *default_tm;
+	VALUE num_columns = INT2NUM(0);
+
+	if( rb_respond_to(self, s_id_fit_to_copy_get) ){
+		num_columns = rb_funcall( self, s_id_fit_to_copy_get, 0 );
+	}
+
+	if ( !rb_obj_is_kind_of(num_columns, rb_cInteger) ) {
+		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 equally. */
+	default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_copy_get( this->typemap.default_typemap );
+
+	return NUM2INT(num_columns);;
+}
+
+static VALUE
+pg_tmir_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
+{
+	t_tmir *this = (t_tmir *) p_typemap;
+	rb_encoding *p_encoding = rb_enc_from_index(enc_idx);
+	VALUE enc = rb_enc_from_encoding(p_encoding);
+	/* field_str is reused in-place by pg_text_dec_copy_row(), so we need to make
+	 * a copy of the string buffer for use in ruby space. */
+	VALUE field_str_copy = rb_str_dup(field_str);
+	rb_str_modify(field_str_copy);
+
+	return rb_funcall( this->self, s_id_typecast_copy_get, 4, field_str_copy, INT2NUM(fieldno), INT2NUM(format), enc );
+}
+
+/*
+ * call-seq:
+ *    typemap.typecast_copy_get( field_str, fieldno, format, encoding )
+ *
+ * Cast a field string received by PG::Connection#get_copy_data.
+ *
+ * This method implementation uses the #default_type_map to cast field_str.
+ * It can be derived to change this behaviour.
+ *
+ * Parameters:
+ * * +field_str+ : The String received from the server.
+ * * +fieldno+ : The field number from left to right.
+ * * +format+ : The format code (0 = text, 1 = binary)
+ * * +encoding+ : The encoding of the connection and encoding the returned
+ *   value should get.
+ *
+ */
+static VALUE
+pg_tmir_typecast_copy_get( VALUE self, VALUE field_str, VALUE fieldno, VALUE format, VALUE enc )
+{
+	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 );
+}
+
+static VALUE
+pg_tmir_s_allocate( VALUE klass )
+{
+	t_tmir *this;
+	VALUE self;
+
+	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;
+	this->typemap.funcs.fit_to_copy_get = pg_tmir_fit_to_copy_get;
+	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;
+	this->self = self;
+
+	return self;
+}
+
+
+void
+init_pg_type_map_in_ruby()
+{
+	s_id_fit_to_result = rb_intern("fit_to_result");
+	s_id_fit_to_query = rb_intern("fit_to_query");
+	s_id_fit_to_copy_get = rb_intern("fit_to_copy_get");
+	s_id_typecast_result_value = rb_intern("typecast_result_value");
+	s_id_typecast_query_param = rb_intern("typecast_query_param");
+	s_id_typecast_copy_get = rb_intern("typecast_copy_get");
+
+	/*
+	 * Document-class: PG::TypeMapInRuby < PG::TypeMap
+	 *
+	 * This class can be used to implement a type map in ruby, typically as a
+	 * #default_type_map in a type map chain.
+	 *
+	 * This API is EXPERIMENTAL and could change in the future.
+	 *
+	 */
+	rb_cTypeMapInRuby = rb_define_class_under( rb_mPG, "TypeMapInRuby", rb_cTypeMap );
+	rb_define_alloc_func( rb_cTypeMapInRuby, pg_tmir_s_allocate );
+	/* rb_define_method( rb_cTypeMapInRuby, "fit_to_result", pg_tmir_fit_to_result, 1 ); */
+	/* rb_define_method( rb_cTypeMapInRuby, "fit_to_query", pg_tmir_fit_to_query, 1 ); */
+	/* rb_define_method( rb_cTypeMapInRuby, "fit_to_copy_get", pg_tmir_fit_to_copy_get_dummy, 0 ); */
+	rb_define_method( rb_cTypeMapInRuby, "typecast_result_value", pg_tmir_typecast_result_value, 3 );
+	rb_define_method( rb_cTypeMapInRuby, "typecast_query_param", pg_tmir_typecast_query_param, 2 );
+	rb_define_method( rb_cTypeMapInRuby, "typecast_copy_get", pg_tmir_typecast_copy_get, 4 );
+	/* rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable"); */
+	rb_include_module( rb_cTypeMapInRuby, rb_mDefaultTypeMappable );
+}