pg 0.17.1-x64-mingw32 → 0.18.0.pre20141017160319-x64-mingw32

data/ext/pg_type_map_by_mri_type.c

@@ -0,0 +1,266 @@
+/*
+ * pg_type_map_by_mri_type.c - PG::TypeMapByMriType class extension
+ * $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"
+
+static VALUE rb_cTypeMapByMriType;
+
+#define FOR_EACH_MRI_TYPE(func) \
+	func(T_FIXNUM) \
+	func(T_TRUE) \
+	func(T_FALSE) \
+	func(T_FLOAT) \
+	func(T_BIGNUM) \
+	func(T_COMPLEX) \
+	func(T_RATIONAL) \
+	func(T_ARRAY) \
+	func(T_STRING) \
+	func(T_SYMBOL) \
+	func(T_OBJECT) \
+	func(T_CLASS) \
+	func(T_MODULE) \
+	func(T_REGEXP) \
+	func(T_HASH) \
+	func(T_STRUCT) \
+	func(T_FILE) \
+	func(T_DATA)
+
+#define DECLARE_CODER(type) \
+	t_pg_coder *coder_##type; \
+	VALUE ask_##type;
+
+typedef struct {
+	t_typemap typemap;
+	struct pg_tmbmt_converter {
+		FOR_EACH_MRI_TYPE( DECLARE_CODER );
+	} coders;
+} t_tmbmt;
+
+
+#define CASE_AND_GET(type) \
+	case type: \
+		p_coder = this->coders.coder_##type; \
+		ask_for_coder = this->coders.ask_##type; \
+		break;
+
+static t_pg_coder *
+pg_tmbmt_typecast_query_param(VALUE self, VALUE param_value, int field)
+{
+	t_tmbmt *this = (t_tmbmt *)DATA_PTR(self);
+	t_pg_coder *p_coder;
+	VALUE ask_for_coder;
+
+	switch(TYPE(param_value)){
+			FOR_EACH_MRI_TYPE( CASE_AND_GET )
+		default:
+			/* unknown MRI type */
+			p_coder = NULL;
+			ask_for_coder = Qnil;
+	}
+
+	if( !NIL_P(ask_for_coder) ){
+		/* 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);
+		}
+
+		if( rb_obj_is_kind_of(obj, rb_cPG_Coder) ){
+			Data_Get_Struct(obj, t_pg_coder, p_coder);
+		}else{
+			rb_raise(rb_eTypeError, "argument %d has invalid type %s (should be nil or some kind of PG::Coder)",
+						field+1, rb_obj_classname( obj ));
+		}
+	}
+
+	return p_coder;
+}
+
+static VALUE
+pg_tmbmt_fit_to_query( VALUE self, VALUE 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 );
+
+static void
+pg_tmbmt_mark( t_tmbmt *this )
+{
+	FOR_EACH_MRI_TYPE( GC_MARK_AS_USED );
+}
+
+#define INIT_VARIABLES(type) \
+	this->coders.coder_##type = NULL; \
+	this->coders.ask_##type = Qnil;
+
+static VALUE
+pg_tmbmt_s_allocate( VALUE klass )
+{
+	t_tmbmt *this;
+	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;
+
+	FOR_EACH_MRI_TYPE( INIT_VARIABLES );
+
+	return self;
+}
+
+#define COMPARE_AND_ASSIGN(type) \
+	else if(!strcmp(p_mri_type, #type)){ \
+		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{ \
+			this->coders.coder_##type = NULL; \
+			this->coders.ask_##type = coder; \
+		} \
+	}
+
+/*
+ * call-seq:
+ *    typemap.[mri_type] = coder
+ *
+ * Assigns a new PG::Coder object to the type map. The decoder
+ * is registered for type casts of the given +mri_type+ .
+ *
+ * +coder+ can be one of the following:
+ * * +nil+        - Values are encoded by +#to_str+
+ * * 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.
+ * * a Proc       - The Proc object is called for each value. It must return a PG::Coder.
+ *
+ * +mri_type+ must be one of the following strings:
+ * * +T_FIXNUM+
+ * * +T_TRUE+
+ * * +T_FALSE+
+ * * +T_FLOAT+
+ * * +T_BIGNUM+
+ * * +T_COMPLEX+
+ * * +T_RATIONAL+
+ * * +T_ARRAY+
+ * * +T_STRING+
+ * * +T_SYMBOL+
+ * * +T_OBJECT+
+ * * +T_CLASS+
+ * * +T_MODULE+
+ * * +T_REGEXP+
+ * * +T_HASH+
+ * * +T_STRUCT+
+ * * +T_FILE+
+ * * +T_DATA+
+ */
+static VALUE
+pg_tmbmt_aset( VALUE self, VALUE mri_type, VALUE coder )
+{
+	t_tmbmt *this = DATA_PTR( self );
+	char *p_mri_type;
+
+	p_mri_type = StringValueCStr(mri_type);
+
+	if(0){}
+	FOR_EACH_MRI_TYPE( COMPARE_AND_ASSIGN )
+	else{
+		VALUE mri_type_inspect = rb_inspect( mri_type );
+		rb_raise(rb_eArgError, "unknown mri_type %s", StringValueCStr(mri_type_inspect));
+	}
+
+	return self;
+}
+
+#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; \
+	}
+
+/*
+ * call-seq:
+ *    typemap.[mri_type] -> coder
+ *
+ * Returns the encoder object for the given +mri_type+
+ *
+ * See #[]= for allowed +mri_type+ .
+ */
+static VALUE
+pg_tmbmt_aref( VALUE self, VALUE mri_type )
+{
+	VALUE coder;
+	t_tmbmt *this = DATA_PTR( self );
+	char *p_mri_type;
+
+	p_mri_type = StringValueCStr(mri_type);
+
+	if(0){}
+	FOR_EACH_MRI_TYPE( COMPARE_AND_GET )
+	else{
+		VALUE mri_type_inspect = rb_inspect( mri_type );
+		rb_raise(rb_eArgError, "unknown mri_type %s", StringValueCStr(mri_type_inspect));
+	}
+
+	return coder;
+}
+
+#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 );
+
+
+/*
+ * call-seq:
+ *    typemap.coders -> Hash
+ *
+ * Returns all mri types and their assigned encoder object.
+ */
+static VALUE
+pg_tmbmt_coders( VALUE self )
+{
+	t_tmbmt *this = DATA_PTR( self );
+	VALUE hash_coders = rb_hash_new();
+
+	FOR_EACH_MRI_TYPE( ADD_TO_HASH );
+
+	return rb_obj_freeze(hash_coders);
+}
+
+void
+init_pg_type_map_by_mri_type()
+{
+	/*
+	 * Document-class: PG::TypeMapByMriType < PG::TypeMap
+	 *
+	 * This type map casts values based on the Ruby object type code of the given value
+	 * to be sent.
+	 *
+	 * 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.
+	 */
+	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 );
+}

data/ext/pg_type_map_by_oid.c

@@ -0,0 +1,341 @@
+/*
+ * 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;
+
+/*
+ * 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 : DATA_PTR(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 = pg_tmbc_default_typemap;
+
+	colmap = pg_tmbc_allocate();
+	DATA_PTR(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(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;
+
+	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) );
+}
+
+static VALUE
+pg_tmbo_fit_to_result( VALUE self, VALUE result )
+{
+	t_tmbo *this = DATA_PTR( self );
+	PGresult *pgresult = pgresult_get( 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;
+	}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 );
+	}
+}
+
+static void
+pg_tmbo_mark( t_tmbo *this )
+{
+	int i;
+
+	for( i=0; i<2; i++){
+		rb_gc_mark(this->format[i].oid_to_coder);
+	}
+}
+
+static VALUE
+pg_tmbo_s_allocate( VALUE klass )
+{
+	t_tmbo *this;
+	VALUE self;
+	int i;
+
+	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->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 = DATA_PTR( 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);
+
+	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 = DATA_PTR( 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 = DATA_PTR( 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 = DATA_PTR( 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 = DATA_PTR( self );
+	return INT2NUM(this->max_rows_for_online_lookup);
+}
+
+/*
+ * call-seq:
+ *    typemap.fit_to_result( result, online_lookup = nil )
+ *
+ * This is an extended version of PG::TypeMap#fit_to_result that
+ * allows explicit selection of online lookup ( online_lookup=true )
+ * or building of a new PG::TypeMapByColumn ( online_lookup=false ).
+ *
+ *
+ */
+static VALUE
+pg_tmbo_fit_to_result_ext( int argc, VALUE *argv, VALUE self )
+{
+	t_tmbo *this = DATA_PTR( self );
+	VALUE result;
+	VALUE online_lookup;
+
+	rb_scan_args(argc, argv, "11", &result, &online_lookup);
+
+	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 ) );
+	}
+
+	if( NIL_P( online_lookup ) ){
+		/* call super */
+		return this->typemap.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 ) ){
+		PGresult *pgresult = pgresult_get( result );
+
+		return pg_tmbo_build_type_map_for_result2( this, pgresult );
+	} else {
+		rb_raise( rb_eArgError, "argument online_lookup %s should be true, false or nil instead",
+				rb_obj_classname( 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.
+	 */
+	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, "fit_to_result", pg_tmbo_fit_to_result_ext, -1 );
+}