pg 0.18.0.pre20141017160319 → 0.18.0.pre20141117110243

data/ext/pg_type_map_by_column.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map_by_column.c,v ec9ef7fb39eb 2014/10/10 18:59:10 lars $
+ * $Id$
  *
  */
 
@@ -10,18 +10,41 @@ static VALUE rb_cTypeMapByColumn;
 static ID s_id_decode;
 static ID s_id_encode;
 
+static VALUE pg_tmbc_s_allocate( VALUE klass );
+
 static VALUE
 pg_tmbc_fit_to_result( VALUE self, VALUE result )
 {
 	int nfields;
 	t_tmbc *this = DATA_PTR( self );
+	t_typemap *default_tm;
+	VALUE sub_typemap;
 
 	nfields = PQnfields( pgresult_get(result) );
 	if ( this->nfields != nfields ) {
 		rb_raise( rb_eArgError, "number of result fields (%d) does not match number of mapped columns (%d)",
 				nfields, this->nfields );
 	}
-	return self;
+
+	/* Ensure that the default type map fits equaly. */
+	default_tm = DATA_PTR( this->typemap.default_typemap );
+	sub_typemap = default_tm->funcs.fit_to_result( this->typemap.default_typemap, result );
+
+	/* Did the default type return the same object ? */
+	if( sub_typemap == this->typemap.default_typemap ){
+		return self;
+	} else {
+		/* Our default type map built a new object, so we need to propagate it
+		 * and build a copy of this type map and set it as default there.. */
+		VALUE new_typemap = pg_tmbc_s_allocate( rb_cTypeMapByColumn );
+		size_t struct_size = sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * nfields;
+		t_tmbc *p_new_typemap = (t_tmbc *)xmalloc(struct_size);
+
+		memcpy( p_new_typemap, this, struct_size );
+		p_new_typemap->typemap.default_typemap = sub_typemap;
+		DATA_PTR(new_typemap) = p_new_typemap;
+		return new_typemap;
+	}
 }
 
 static VALUE
@@ -29,12 +52,18 @@ pg_tmbc_fit_to_query( VALUE self, VALUE params )
 {
 	int nfields;
 	t_tmbc *this = DATA_PTR( self );
+	t_typemap *default_tm;
 
 	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)",
 				nfields, this->nfields );
 	}
+
+	/* Ensure that the default type map fits equaly. */
+	default_tm = DATA_PTR( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
+
 	return self;
 }
 
@@ -42,47 +71,59 @@ static int
 pg_tmbc_fit_to_copy_get( VALUE self )
 {
 	t_tmbc *this = DATA_PTR( self );
+
+	/* Ensure that the default type map fits equaly. */
+	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_copy_get( this->typemap.default_typemap );
+
 	return this->nfields;
 }
 
 
 VALUE
-pg_tmbc_result_value(VALUE result, int tuple, int field)
+pg_tmbc_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 {
-	char * val;
-	int len;
 	t_pg_coder *p_coder = NULL;
-	t_pg_coder_dec_func dec_func;
 	t_pg_result *p_result = pgresult_get_this(result);
-	t_tmbc *this = (t_tmbc *) p_result->p_typemap;
+	t_tmbc *this = (t_tmbc *) p_typemap;
+	t_typemap *default_tm;
 
 	if (PQgetisnull(p_result->pgresult, tuple, field)) {
 		return Qnil;
 	}
 
-	val = PQgetvalue( p_result->pgresult, tuple, field );
-	len = PQgetlength( p_result->pgresult, tuple, field );
+	p_coder = this->convs[field].cconv;
 
-	if( this ){
-		p_coder = this->convs[field].cconv;
+	if( p_coder ){
+		char * val = PQgetvalue( p_result->pgresult, tuple, field );
+		int len = PQgetlength( p_result->pgresult, tuple, field );
 
-		if( p_coder && p_coder->dec_func ){
+		if( p_coder->dec_func ){
 			return p_coder->dec_func(p_coder, val, len, tuple, field, ENCODING_GET(result));
+		} else {
+			t_pg_coder_dec_func dec_func;
+			dec_func = pg_coder_dec_func( p_coder, PQfformat(p_result->pgresult, field) );
+			return dec_func(p_coder, val, len, tuple, field, ENCODING_GET(result));
 		}
 	}
 
-	dec_func = pg_coder_dec_func( p_coder, PQfformat(p_result->pgresult, field) );
-	return dec_func( p_coder, val, len, tuple, field, ENCODING_GET(result) );
+	default_tm = DATA_PTR( this->typemap.default_typemap );
+	return default_tm->funcs.typecast_result_value( default_tm, result, tuple, field );
 }
 
 static t_pg_coder *
-pg_tmbc_typecast_query_param(VALUE self, VALUE param_value, int field)
+pg_tmbc_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 {
-	t_tmbc *this = (t_tmbc *)DATA_PTR(self);
+	t_tmbc *this = (t_tmbc *) p_typemap;
 
 	/* Number of fields were already checked in pg_tmbc_fit_to_query() */
 	t_pg_coder *p_coder = this->convs[field].cconv;
 
+	if( !p_coder ){
+		t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+		return default_tm->funcs.typecast_query_param( default_tm, param_value, field );
+	}
+
 	return p_coder;
 }
 
@@ -100,14 +141,19 @@ pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, i
 
 	p_coder = this->convs[fieldno].cconv;
 
+	if( !p_coder ){
+		t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+		return default_tm->funcs.typecast_copy_get( default_tm, field_str, fieldno, format, enc_idx );
+	}
+
 	dec_func = pg_coder_dec_func( p_coder, format );
 
 	/* Is it a pure String conversion? Then we can directly send field_str to the user. */
-	if( format == 0 && dec_func == pg_text_dec_string ){
+	if( dec_func == pg_text_dec_string ){
 		PG_ENCODING_SET_NOCHECK( field_str, enc_idx );
 		return field_str;
 	}
-	if( format == 1 && dec_func == pg_bin_dec_bytea ){
+	if( dec_func == pg_bin_dec_bytea ){
 		PG_ENCODING_SET_NOCHECK( field_str, rb_ascii8bit_encindex() );
 		return field_str;
 	}
@@ -115,7 +161,7 @@ pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, i
 	return dec_func( p_coder, RSTRING_PTR(field_str), RSTRING_LEN(field_str), 0, fieldno, enc_idx );
 }
 
-const t_typemap pg_tmbc_default_typemap = {
+const struct pg_typemap_funcs pg_tmbc_funcs = {
 	.fit_to_result = pg_tmbc_fit_to_result,
 	.fit_to_query = pg_tmbc_fit_to_query,
 	.fit_to_copy_get = pg_tmbc_fit_to_copy_get,
@@ -130,8 +176,9 @@ pg_tmbc_mark( t_tmbc *this )
 	int i;
 
 	/* allocated but not initialized ? */
-	if( !this ) return;
+	if( this == (t_tmbc *)&pg_typemap_funcs ) return;
 
+	rb_gc_mark(this->typemap.default_typemap);
 	for( i=0; i<this->nfields; i++){
 		t_pg_coder *p_coder = this->convs[i].cconv;
 		if( p_coder )
@@ -139,10 +186,19 @@ pg_tmbc_mark( t_tmbc *this )
 	}
 }
 
+static void
+pg_tmbc_free( t_tmbc *this )
+{
+	/* allocated but not initialized ? */
+	if( this == (t_tmbc *)&pg_typemap_funcs ) return;
+	xfree( this );
+}
+
 static VALUE
 pg_tmbc_s_allocate( VALUE klass )
 {
-	return Data_Wrap_Struct( klass, pg_tmbc_mark, -1, NULL );
+	/* Use pg_typemap_funcs as interim struct until #initialize is called. */
+	return Data_Wrap_Struct( klass, pg_tmbc_mark, pg_tmbc_free, (t_tmbc *)&pg_typemap_funcs );
 }
 
 VALUE
@@ -160,7 +216,7 @@ pg_tmbc_allocate()
  * The length of the Array corresponds to
  * the number of columns or bind parameters this type map is usable for.
  *
- * A +nil+ value will cast the given field to a String object.
+ * A +nil+ value will forward the given field to the #default_type_map .
  */
 static VALUE
 pg_tmbc_init(VALUE self, VALUE conv_ary)
@@ -175,7 +231,8 @@ pg_tmbc_init(VALUE self, VALUE conv_ary)
 	this = xmalloc(sizeof(t_tmbc) + sizeof(struct pg_tmbc_converter) * conv_ary_len);
 	/* Set nfields to 0 at first, so that GC mark function doesn't access uninitialized memory. */
 	this->nfields = 0;
-	this->typemap = pg_tmbc_default_typemap;
+	this->typemap.funcs = pg_tmbc_funcs;
+	this->typemap.default_typemap = pg_typemap_all_strings;
 	DATA_PTR(self) = this;
 
 	for(i=0; i<conv_ary_len; i++)
@@ -251,4 +308,5 @@ init_pg_type_map_by_column()
 	rb_define_alloc_func( rb_cTypeMapByColumn, pg_tmbc_s_allocate );
 	rb_define_method( rb_cTypeMapByColumn, "initialize", pg_tmbc_init, 1 );
 	rb_define_method( rb_cTypeMapByColumn, "coders", pg_tmbc_coders, 0 );
+	rb_include_module( rb_cTypeMapByColumn, rb_mDefaultTypeMappable );
 }

data/ext/pg_type_map_by_mri_type.c

@@ -1,12 +1,10 @@
 /*
  * pg_type_map_by_mri_type.c - PG::TypeMapByMriType class extension
- * $Id: pg_type_map_by_mri_type.c,v 4227fdc5f0ac 2014/10/07 17:42:09 lars $
+ * $Id$
  *
  * This type map can be used to select value encoders based on the MRI-internal
  * value type code.
  *
- * This class is planned to get replaced by a PG::TypeMapByClass implementation.
- *
  */
 
 #include "pg.h"
@@ -35,7 +33,8 @@ static VALUE rb_cTypeMapByMriType;
 
 #define DECLARE_CODER(type) \
 	t_pg_coder *coder_##type; \
-	VALUE ask_##type;
+	VALUE ask_##type; \
+	VALUE coder_obj_##type;
 
 typedef struct {
 	t_typemap typemap;
@@ -52,9 +51,9 @@ typedef struct {
 		break;
 
 static t_pg_coder *
-pg_tmbmt_typecast_query_param(VALUE self, VALUE param_value, int field)
+pg_tmbmt_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 {
-	t_tmbmt *this = (t_tmbmt *)DATA_PTR(self);
+	t_tmbmt *this = (t_tmbmt *)p_typemap;
 	t_pg_coder *p_coder;
 	VALUE ask_for_coder;
 
@@ -70,11 +69,7 @@ pg_tmbmt_typecast_query_param(VALUE self, VALUE param_value, int field)
 		/* No static Coder object, but proc/method given to ask for the Coder to use. */
 		VALUE obj;
 
-		if( TYPE(ask_for_coder) == T_SYMBOL ){
-			obj = rb_funcall(self, SYM2ID(ask_for_coder), 1, param_value);
-		}else{
-			obj = rb_funcall(ask_for_coder, rb_intern("call"), 1, param_value);
-		}
+		obj = rb_funcall(ask_for_coder, rb_intern("call"), 1, param_value);
 
 		if( rb_obj_is_kind_of(obj, rb_cPG_Coder) ){
 			Data_Get_Struct(obj, t_pg_coder, p_coder);
@@ -84,28 +79,39 @@ pg_tmbmt_typecast_query_param(VALUE self, VALUE param_value, int field)
 		}
 	}
 
+	if( !p_coder ){
+		t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+		return default_tm->funcs.typecast_query_param( default_tm, param_value, field );
+	}
+
 	return p_coder;
 }
 
 static VALUE
 pg_tmbmt_fit_to_query( VALUE self, VALUE params )
 {
+	t_tmbmt *this = (t_tmbmt *)DATA_PTR(self);
+	/* Nothing to check at this typemap, but ensure that the default type map fits. */
+	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
 	return self;
 }
 
 #define GC_MARK_AS_USED(type) \
-	if(this->coders.coder_##type) rb_gc_mark(this->coders.coder_##type->coder_obj); \
-	rb_gc_mark( this->coders.ask_##type );
+	rb_gc_mark( this->coders.ask_##type ); \
+	rb_gc_mark( this->coders.coder_obj_##type );
 
 static void
 pg_tmbmt_mark( t_tmbmt *this )
 {
+	rb_gc_mark(this->typemap.default_typemap);
 	FOR_EACH_MRI_TYPE( GC_MARK_AS_USED );
 }
 
 #define INIT_VARIABLES(type) \
 	this->coders.coder_##type = NULL; \
-	this->coders.ask_##type = Qnil;
+	this->coders.ask_##type = Qnil; \
+	this->coders.coder_obj_##type = Qnil;
 
 static VALUE
 pg_tmbmt_s_allocate( VALUE klass )
@@ -114,12 +120,13 @@ pg_tmbmt_s_allocate( VALUE klass )
 	VALUE self;
 
 	self = Data_Make_Struct( klass, t_tmbmt, pg_tmbmt_mark, -1, this );
-	this->typemap.fit_to_result = pg_typemap_fit_to_result;
-	this->typemap.fit_to_query = pg_tmbmt_fit_to_query;
-	this->typemap.fit_to_copy_get = pg_typemap_fit_to_copy_get;
-	this->typemap.typecast_result_value = pg_typemap_result_value;
-	this->typemap.typecast_query_param = pg_tmbmt_typecast_query_param;
-	this->typemap.typecast_copy_get = pg_typemap_typecast_copy_get;
+	this->typemap.funcs.fit_to_result = pg_typemap_fit_to_result;
+	this->typemap.funcs.fit_to_query = pg_tmbmt_fit_to_query;
+	this->typemap.funcs.fit_to_copy_get = pg_typemap_fit_to_copy_get;
+	this->typemap.funcs.typecast_result_value = pg_typemap_result_value;
+	this->typemap.funcs.typecast_query_param = pg_tmbmt_typecast_query_param;
+	this->typemap.funcs.typecast_copy_get = pg_typemap_typecast_copy_get;
+	this->typemap.default_typemap = pg_typemap_all_strings;
 
 	FOR_EACH_MRI_TYPE( INIT_VARIABLES );
 
@@ -128,12 +135,16 @@ pg_tmbmt_s_allocate( VALUE klass )
 
 #define COMPARE_AND_ASSIGN(type) \
 	else if(!strcmp(p_mri_type, #type)){ \
+		this->coders.coder_obj_##type = coder; \
 		if(NIL_P(coder)){ \
 			this->coders.coder_##type = NULL; \
 			this->coders.ask_##type = Qnil; \
 		}else if(rb_obj_is_kind_of(coder, rb_cPG_Coder)){ \
 			Data_Get_Struct(coder, t_pg_coder, this->coders.coder_##type); \
 			this->coders.ask_##type = Qnil; \
+		}else if(RB_TYPE_P(coder, T_SYMBOL)){ \
+			this->coders.coder_##type = NULL; \
+			this->coders.ask_##type = rb_obj_method( self, coder ); \
 		}else{ \
 			this->coders.coder_##type = NULL; \
 			this->coders.ask_##type = coder; \
@@ -144,11 +155,11 @@ pg_tmbmt_s_allocate( VALUE klass )
  * call-seq:
  *    typemap.[mri_type] = coder
  *
- * Assigns a new PG::Coder object to the type map. The decoder
+ * Assigns a new PG::Coder object to the type map. The encoder
  * is registered for type casts of the given +mri_type+ .
  *
  * +coder+ can be one of the following:
- * * +nil+        - Values are encoded by +#to_str+
+ * * +nil+        - Values are forwarded to the #default_type_map .
  * * a PG::Coder  - Values are encoded by the given encoder
  * * a Symbol     - The method of this type map (or a derivation) that is called for each value to sent.
  *   It must return a PG::Coder.
@@ -194,7 +205,7 @@ pg_tmbmt_aset( VALUE self, VALUE mri_type, VALUE coder )
 
 #define COMPARE_AND_GET(type) \
 	else if(!strcmp(p_mri_type, #type)){ \
-		coder = this->coders.coder_##type ? this->coders.coder_##type->coder_obj : this->coders.ask_##type; \
+		coder = this->coders.coder_obj_##type; \
 	}
 
 /*
@@ -225,7 +236,7 @@ pg_tmbmt_aref( VALUE self, VALUE mri_type )
 }
 
 #define ADD_TO_HASH(type) \
-	rb_hash_aset( hash_coders, rb_obj_freeze(rb_str_new2(#type)), this->coders.coder_##type ? this->coders.coder_##type->coder_obj : this->coders.ask_##type );
+	rb_hash_aset( hash_coders, rb_obj_freeze(rb_str_new2(#type)), this->coders.coder_obj_##type );
 
 
 /*
@@ -257,10 +268,17 @@ init_pg_type_map_by_mri_type()
 	 * This type map is usable for type casting query bind parameters and COPY data
 	 * for PG::Connection#put_copy_data . Therefore only encoders might be assigned by
 	 * the #[]= method.
+	 *
+	 * _Note_ : This type map is not portable across Ruby implementations and is less flexible
+	 * than PG::TypeMapByClass.
+	 * It is kept only for performance comparisons, but PG::TypeMapByClass proved to be equally
+	 * fast in almost all cases.
+	 *
 	 */
 	rb_cTypeMapByMriType = rb_define_class_under( rb_mPG, "TypeMapByMriType", rb_cTypeMap );
 	rb_define_alloc_func( rb_cTypeMapByMriType, pg_tmbmt_s_allocate );
 	rb_define_method( rb_cTypeMapByMriType, "[]=", pg_tmbmt_aset, 2 );
 	rb_define_method( rb_cTypeMapByMriType, "[]", pg_tmbmt_aref, 1 );
 	rb_define_method( rb_cTypeMapByMriType, "coders", pg_tmbmt_coders, 0 );
+	rb_include_module( rb_cTypeMapByMriType, rb_mDefaultTypeMappable );
 }

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 4227fdc5f0ac 2014/10/07 17:42:09 lars $
+ * $Id$
  *
  */
 
@@ -23,6 +23,9 @@ typedef struct {
 	} 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.
@@ -63,7 +66,8 @@ pg_tmbo_build_type_map_for_result2( t_tmbo *this, PGresult *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 = pg_tmbc_default_typemap;
+	p_colmap->typemap.funcs = pg_tmbc_funcs;
+	p_colmap->typemap.default_typemap = pg_typemap_all_strings;
 
 	colmap = pg_tmbc_allocate();
 	DATA_PTR(colmap) = p_colmap;
@@ -84,30 +88,33 @@ pg_tmbo_build_type_map_for_result2( t_tmbo *this, PGresult *pgresult )
 }
 
 static VALUE
-pg_tmbo_result_value(VALUE result, int tuple, int field)
+pg_tmbo_result_value(t_typemap *p_typemap, VALUE result, int tuple, int field)
 {
-	char * val;
-	int len;
 	int format;
 	t_pg_coder *p_coder;
-	t_pg_coder_dec_func dec_func;
 	t_pg_result *p_result = pgresult_get_this(result);
-	t_tmbo *this = (t_tmbo*) p_result->p_typemap;
+	t_tmbo *this = (t_tmbo*) p_typemap;
+	t_typemap *default_tm;
 
 	if (PQgetisnull(p_result->pgresult, tuple, field)) {
 		return Qnil;
 	}
 
-	val = PQgetvalue( p_result->pgresult, tuple, field );
-	len = PQgetlength( p_result->pgresult, tuple, field );
 	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) );
-	dec_func = pg_coder_dec_func( p_coder, format );
-	return dec_func( p_coder, val, len, tuple, field, ENCODING_GET(result) );
+	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, ENCODING_GET(result) );
+	}
+
+	default_tm = DATA_PTR( this->typemap.default_typemap );
+	return default_tm->funcs.typecast_result_value( default_tm, result, tuple, field );
 }
 
 static VALUE
@@ -116,14 +123,33 @@ pg_tmbo_fit_to_result( VALUE self, VALUE result )
 	t_tmbo *this = DATA_PTR( self );
 	PGresult *pgresult = pgresult_get( result );
 
+	/* Ensure that the default type map fits equaly. */
+	t_typemap *default_tm = DATA_PTR( 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() */
-		return self;
+
+	/* 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 = DATA_PTR(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.
 		 */
-		return pg_tmbo_build_type_map_for_result2( this, pgresult );
+		VALUE new_typemap = pg_tmbo_build_type_map_for_result2( this, pgresult );
+		t_tmbo *p_new_typemap = DATA_PTR(new_typemap);
+		p_new_typemap->typemap.default_typemap = sub_typemap;
+		return new_typemap;
 	}
 }
 
@@ -132,6 +158,7 @@ pg_tmbo_mark( t_tmbo *this )
 {
 	int i;
 
+	rb_gc_mark(this->typemap.default_typemap);
 	for( i=0; i<2; i++){
 		rb_gc_mark(this->format[i].oid_to_coder);
 	}
@@ -146,12 +173,13 @@ pg_tmbo_s_allocate( VALUE klass )
 
 	self = Data_Make_Struct( klass, t_tmbo, pg_tmbo_mark, -1, this );
 
-	this->typemap.fit_to_result = pg_tmbo_fit_to_result;
-	this->typemap.fit_to_query = pg_typemap_fit_to_query;
-	this->typemap.fit_to_copy_get = pg_typemap_fit_to_copy_get;
-	this->typemap.typecast_result_value = pg_tmbo_result_value;
-	this->typemap.typecast_query_param = pg_typemap_typecast_query_param;
-	this->typemap.typecast_copy_get = pg_typemap_typecast_copy_get;
+	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++){
@@ -302,7 +330,7 @@ pg_tmbo_fit_to_result_ext( int argc, VALUE *argv, VALUE self )
 
 	if( NIL_P( online_lookup ) ){
 		/* call super */
-		return this->typemap.fit_to_result(self, result);
+		return this->typemap.funcs.fit_to_result(self, result);
 	} else if( RB_TYPE_P( online_lookup, T_TRUE ) ){
 		return self;
 	} else if( RB_TYPE_P( online_lookup, T_FALSE ) ){
@@ -329,6 +357,9 @@ init_pg_type_map_by_oid()
 	 *
 	 * 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 );
@@ -338,4 +369,5 @@ 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, "fit_to_result", pg_tmbo_fit_to_result_ext, -1 );
+	rb_include_module( rb_cTypeMapByOid, rb_mDefaultTypeMappable );
 }