pg 1.3.0.rc2-x64-mingw-ucrt

data/ext/pg_type_map.c

@@ -0,0 +1,199 @@
+/*
+ * pg_column_map.c - PG::ColumnMap class extension
+ * $Id$
+ *
+ */
+
+#include "pg.h"
+
+void
+pg_typemap_mark( void *_this )
+{
+	t_typemap *this = (t_typemap *)_this;
+	rb_gc_mark_movable(this->default_typemap);
+}
+
+size_t
+pg_typemap_memsize( const void *_this )
+{
+	t_typemap *this = (t_typemap *)_this;
+	return sizeof(*this);
+}
+
+void
+pg_typemap_compact( void *_this )
+{
+	t_typemap *this = (t_typemap *)_this;
+	pg_gc_location(this->default_typemap);
+}
+
+const rb_data_type_t pg_typemap_type = {
+	"PG::TypeMap",
+	{
+		pg_typemap_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_typemap_memsize,
+		pg_compact_callback(pg_typemap_compact),
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE rb_cTypeMap;
+VALUE rb_mDefaultTypeMappable;
+static ID s_id_fit_to_query;
+static ID s_id_fit_to_result;
+
+NORETURN( VALUE
+pg_typemap_fit_to_result( VALUE self, VALUE result ));
+NORETURN( VALUE
+pg_typemap_fit_to_query( VALUE self, VALUE params ));
+NORETURN( int
+pg_typemap_fit_to_copy_get( VALUE self ));
+NORETURN( VALUE
+pg_typemap_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field ));
+NORETURN( t_pg_coder *
+pg_typemap_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field ));
+NORETURN( VALUE
+pg_typemap_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx ));
+
+VALUE
+pg_typemap_fit_to_result( VALUE self, VALUE result )
+{
+	rb_raise( rb_eNotImpError, "type map %s is not suitable to map result values", rb_obj_classname(self) );
+}
+
+VALUE
+pg_typemap_fit_to_query( VALUE self, VALUE params )
+{
+	rb_raise( rb_eNotImpError, "type map %s is not suitable to map query params", rb_obj_classname(self) );
+}
+
+int
+pg_typemap_fit_to_copy_get( VALUE self )
+{
+	rb_raise( rb_eNotImpError, "type map %s is not suitable to map get_copy_data results", rb_obj_classname(self) );
+}
+
+VALUE
+pg_typemap_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
+{
+	rb_raise( rb_eNotImpError, "type map is not suitable to map result values" );
+}
+
+t_pg_coder *
+pg_typemap_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
+{
+	rb_raise( rb_eNotImpError, "type map is not suitable to map query params" );
+}
+
+VALUE
+pg_typemap_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
+{
+	rb_raise( rb_eNotImpError, "type map is not suitable to map get_copy_data results" );
+}
+
+const struct pg_typemap_funcs pg_typemap_funcs = {
+	pg_typemap_fit_to_result,
+	pg_typemap_fit_to_query,
+	pg_typemap_fit_to_copy_get,
+	pg_typemap_result_value,
+	pg_typemap_typecast_query_param,
+	pg_typemap_typecast_copy_get
+};
+
+static VALUE
+pg_typemap_s_allocate( VALUE klass )
+{
+	VALUE self;
+	t_typemap *this;
+
+	self = TypedData_Make_Struct( klass, t_typemap, &pg_typemap_type, this );
+	this->funcs = pg_typemap_funcs;
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *    res.default_type_map = typemap
+ *
+ * Set the default TypeMap that is used for values that could not be
+ * casted by this type map.
+ *
+ * +typemap+ must be a kind of PG::TypeMap
+ *
+ */
+static VALUE
+pg_typemap_default_type_map_set(VALUE self, VALUE typemap)
+{
+	t_typemap *this = RTYPEDDATA_DATA( self );
+	t_typemap *tm;
+	UNUSED(tm);
+
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
+	this->default_typemap = typemap;
+
+	return typemap;
+}
+
+/*
+ * call-seq:
+ *    res.default_type_map -> TypeMap
+ *
+ * Returns the default TypeMap that is currently set for values that could not be
+ * casted by this type map.
+ *
+ * Returns a kind of PG::TypeMap.
+ *
+ */
+static VALUE
+pg_typemap_default_type_map_get(VALUE self)
+{
+	t_typemap *this = RTYPEDDATA_DATA( self );
+
+	return this->default_typemap;
+}
+
+/*
+ * call-seq:
+ *    res.with_default_type_map( typemap )
+ *
+ * Set the default TypeMap that is used for values that could not be
+ * casted by this type map.
+ *
+ * +typemap+ must be a kind of PG::TypeMap
+ *
+ * Returns self.
+ */
+static VALUE
+pg_typemap_with_default_type_map(VALUE self, VALUE typemap)
+{
+	pg_typemap_default_type_map_set( self, typemap );
+	return self;
+}
+
+void
+init_pg_type_map()
+{
+	s_id_fit_to_query = rb_intern("fit_to_query");
+	s_id_fit_to_result = rb_intern("fit_to_result");
+
+	/*
+	 * Document-class: PG::TypeMap < Object
+	 *
+	 * This is the base class for type maps.
+	 * See derived classes for implementations of different type cast strategies
+	 * ( PG::TypeMapByColumn, PG::TypeMapByOid ).
+	 *
+	 */
+	rb_cTypeMap = rb_define_class_under( rb_mPG, "TypeMap", rb_cObject );
+	rb_define_alloc_func( rb_cTypeMap, pg_typemap_s_allocate );
+
+	rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable");
+	rb_define_method( rb_mDefaultTypeMappable, "default_type_map=", pg_typemap_default_type_map_set, 1 );
+	rb_define_method( rb_mDefaultTypeMappable, "default_type_map", pg_typemap_default_type_map_get, 0 );
+	rb_define_method( rb_mDefaultTypeMappable, "with_default_type_map", pg_typemap_with_default_type_map, 1 );
+}

data/ext/pg_type_map_all_strings.c

@@ -0,0 +1,129 @@
+/*
+ * pg_type_map_all_strings.c - PG::TypeMapAllStrings class extension
+ * $Id$
+ *
+ * This is the default typemap.
+ *
+ */
+
+#include "pg.h"
+
+static const rb_data_type_t pg_tmas_type = {
+	"PG::TypeMapAllStrings",
+	{
+		pg_typemap_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_typemap_memsize,
+		pg_compact_callback(pg_typemap_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+VALUE rb_cTypeMapAllStrings;
+VALUE pg_typemap_all_strings;
+
+static VALUE
+pg_tmas_fit_to_result( VALUE self, VALUE result )
+{
+	return self;
+}
+
+static VALUE
+pg_tmas_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
+{
+	VALUE ret;
+	char * val;
+	int len;
+	t_pg_result *p_result = pgresult_get_this(result);
+
+	if (PQgetisnull(p_result->pgresult, tuple, field)) {
+		return Qnil;
+	}
+
+	val = PQgetvalue( p_result->pgresult, tuple, field );
+	len = PQgetlength( p_result->pgresult, tuple, field );
+
+	if ( 0 == PQfformat(p_result->pgresult, field) ) {
+		ret = pg_text_dec_string(NULL, val, len, tuple, field, p_result->enc_idx);
+	} else {
+		ret = pg_bin_dec_bytea(NULL, val, len, tuple, field, p_result->enc_idx);
+	}
+
+	return ret;
+}
+
+static VALUE
+pg_tmas_fit_to_query( VALUE self, VALUE params )
+{
+	return self;
+}
+
+static t_pg_coder *
+pg_tmas_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
+{
+	return NULL;
+}
+
+static int
+pg_tmas_fit_to_copy_get( VALUE self )
+{
+	/* We can not predict the number of columns for copy */
+	return 0;
+}
+
+static VALUE
+pg_tmas_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
+{
+	if( format == 0 ){
+		PG_ENCODING_SET_NOCHECK( field_str, enc_idx );
+	} else {
+		PG_ENCODING_SET_NOCHECK( field_str, rb_ascii8bit_encindex() );
+	}
+	return field_str;
+}
+
+static VALUE
+pg_tmas_s_allocate( VALUE klass )
+{
+	t_typemap *this;
+	VALUE self;
+
+	self = TypedData_Make_Struct( klass, t_typemap, &pg_tmas_type, this );
+
+	this->funcs.fit_to_result = pg_tmas_fit_to_result;
+	this->funcs.fit_to_query = pg_tmas_fit_to_query;
+	this->funcs.fit_to_copy_get = pg_tmas_fit_to_copy_get;
+	this->funcs.typecast_result_value = pg_tmas_result_value;
+	this->funcs.typecast_query_param = pg_tmas_typecast_query_param;
+	this->funcs.typecast_copy_get = pg_tmas_typecast_copy_get;
+
+	return self;
+}
+
+
+void
+init_pg_type_map_all_strings()
+{
+	/*
+	 * Document-class: PG::TypeMapAllStrings < PG::TypeMap
+	 *
+	 * This type map casts all values received from the database server to Strings
+	 * and sends all values to the server after conversion to String by +#to_s+ .
+	 * That means, it is hard coded to PG::TextEncoder::String for value encoding
+	 * and to PG::TextDecoder::String for text format respectively PG::BinaryDecoder::Bytea
+	 * for binary format received from the server.
+	 *
+	 * It is suitable for type casting query bind parameters, result values and
+	 * COPY IN/OUT data.
+	 *
+	 * This is the default type map for each PG::Connection .
+	 *
+	 */
+	rb_cTypeMapAllStrings = rb_define_class_under( rb_mPG, "TypeMapAllStrings", rb_cTypeMap );
+	rb_define_alloc_func( rb_cTypeMapAllStrings, pg_tmas_s_allocate );
+
+	pg_typemap_all_strings = rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 );
+	rb_gc_register_address( &pg_typemap_all_strings );
+}

data/ext/pg_type_map_by_class.c

@@ -0,0 +1,269 @@
+/*
+ * pg_type_map_by_class.c - PG::TypeMapByClass class extension
+ * $Id$
+ *
+ * This type map can be used to select value encoders based on the class
+ * of the given value to be send.
+ *
+ */
+
+#include "pg.h"
+
+static VALUE rb_cTypeMapByClass;
+
+typedef struct {
+	t_typemap typemap;
+
+	VALUE klass_to_coder;
+	VALUE self;
+
+	struct pg_tmbk_coder_cache_entry {
+		VALUE klass;
+		t_pg_coder *p_coder;
+	} cache_row[0x100];
+} t_tmbk;
+
+/*
+ * We use 8 Bits of the klass object id as index to a 256 entry cache.
+ * This avoids full lookups in most cases.
+ */
+#define CACHE_LOOKUP(this, klass) ( &this->cache_row[(((unsigned long)klass) >> 8) & 0xff] )
+
+
+static t_pg_coder *
+pg_tmbk_lookup_klass(t_tmbk *this, VALUE klass, VALUE param_value)
+{
+	t_pg_coder *p_coder;
+	struct pg_tmbk_coder_cache_entry *p_ce;
+
+	p_ce = CACHE_LOOKUP(this, klass);
+
+	/* Is the cache entry for the expected klass? */
+	if( p_ce->klass == klass ) {
+		p_coder = p_ce->p_coder;
+	} else {
+		/* No, then do a full lookup based on the ancestors. */
+		VALUE obj = rb_hash_lookup( this->klass_to_coder, klass );
+
+		if( NIL_P(obj) ){
+			int i;
+			VALUE ancestors = rb_mod_ancestors( klass );
+
+			Check_Type( ancestors, T_ARRAY );
+			/* Don't look at the first element, it's expected to equal klass. */
+			for( i=1; i<RARRAY_LEN(ancestors); i++ ){
+				obj = rb_hash_lookup( this->klass_to_coder, rb_ary_entry( ancestors, i) );
+
+				if( !NIL_P(obj) )
+					break;
+			}
+		}
+
+		if(NIL_P(obj)){
+			p_coder = NULL;
+		}else if(rb_obj_is_kind_of(obj, rb_cPG_Coder)){
+			TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
+		}else{
+			if( RB_TYPE_P(obj, T_SYMBOL) ){
+				/* A Symbol: Call the method with this name. */
+				obj = rb_funcall(this->self, SYM2ID(obj), 1, param_value);
+			}else{
+				/* A Proc object (or something that responds to #call). */
+				obj = rb_funcall(obj, rb_intern("call"), 1, param_value);
+			}
+
+			if( NIL_P(obj) ){
+				p_coder = NULL;
+			}else{
+				/* Check retrieved coder type */
+				TypedData_Get_Struct(obj, t_pg_coder, &pg_coder_type, p_coder);
+			}
+
+			/* We can not cache coders retrieved by ruby code, because we can not anticipate
+			 * the returned Coder object. */
+			return p_coder;
+		}
+
+		/* Write the retrieved coder to the cache */
+		p_ce->klass = klass;
+		p_ce->p_coder = p_coder;
+	}
+	return p_coder;
+}
+
+
+static t_pg_coder *
+pg_tmbk_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
+{
+	t_tmbk *this = (t_tmbk *)p_typemap;
+	t_pg_coder *p_coder;
+
+  p_coder = pg_tmbk_lookup_klass( this, rb_obj_class(param_value), param_value );
+
+	if( !p_coder ){
+		t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
+		return default_tm->funcs.typecast_query_param( default_tm, param_value, field );
+	}
+
+	return p_coder;
+}
+
+static VALUE
+pg_tmbk_fit_to_query( VALUE self, VALUE params )
+{
+	t_tmbk *this = (t_tmbk *)RTYPEDDATA_DATA(self);
+	/* Nothing to check at this typemap, but ensure that the default type map fits. */
+	t_typemap *default_tm = RTYPEDDATA_DATA( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_query( this->typemap.default_typemap, params );
+	return self;
+}
+
+static void
+pg_tmbk_mark( void *_this )
+{
+	t_tmbk *this = (t_tmbk *)_this;
+	pg_typemap_mark(&this->typemap);
+	rb_gc_mark_movable(this->klass_to_coder);
+	rb_gc_mark_movable(this->self);
+}
+
+static size_t
+pg_tmbk_memsize( const void *_this )
+{
+	const t_tmbk *this = (const t_tmbk *)_this;
+	return sizeof(*this);
+}
+
+static void
+pg_tmbk_compact(void *ptr)
+{
+	t_tmbk *this = (t_tmbk *)ptr;
+
+	pg_typemap_compact(&this->typemap);
+	pg_gc_location(this->klass_to_coder);
+	pg_gc_location(this->self);
+
+	/* Clear the cache, to be safe from changes of klass VALUE by GC.compact. */
+	memset(&this->cache_row, 0, sizeof(this->cache_row));
+}
+
+static const rb_data_type_t pg_tmbk_type = {
+	"PG::TypeMapByClass",
+	{
+		pg_tmbk_mark,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_tmbk_memsize,
+		pg_compact_callback(pg_tmbk_compact),
+	},
+	&pg_typemap_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+pg_tmbk_s_allocate( VALUE klass )
+{
+	t_tmbk *this;
+	VALUE self;
+
+	self = TypedData_Make_Struct( klass, t_tmbk, &pg_tmbk_type, this );
+	this->typemap.funcs.fit_to_result = pg_typemap_fit_to_result;
+	this->typemap.funcs.fit_to_query = pg_tmbk_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_tmbk_typecast_query_param;
+	this->typemap.funcs.typecast_copy_get = pg_typemap_typecast_copy_get;
+	this->typemap.default_typemap = pg_typemap_all_strings;
+
+	/* We need to store self in the this-struct, because pg_tmbk_typecast_query_param(),
+	 * is called with the this-pointer only. */
+	this->self = self;
+	this->klass_to_coder = rb_hash_new();
+
+	/* The cache is properly initialized by TypedData_Make_Struct(). */
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *    typemap.[class] = coder
+ *
+ * Assigns a new PG::Coder object to the type map. The encoder
+ * is chosen for all values that are a kind of the given +class+ .
+ *
+ * +coder+ can be one of the following:
+ * * +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 or +nil+ .
+ * * a Proc       - The Proc object is called for each value. It must return a PG::Coder or +nil+ .
+ *
+ */
+static VALUE
+pg_tmbk_aset( VALUE self, VALUE klass, VALUE coder )
+{
+	t_tmbk *this = RTYPEDDATA_DATA( self );
+
+	if(NIL_P(coder)){
+		rb_hash_delete( this->klass_to_coder, klass );
+	}else{
+		rb_hash_aset( this->klass_to_coder, klass, coder );
+	}
+
+	/* The cache lookup key can be a derivation of the klass.
+	 * So we can not expire the cache selectively. */
+	memset( &this->cache_row, 0, sizeof(this->cache_row) );
+
+	return coder;
+}
+
+/*
+ * call-seq:
+ *    typemap.[class] -> coder
+ *
+ * Returns the encoder object for the given +class+
+ */
+static VALUE
+pg_tmbk_aref( VALUE self, VALUE klass )
+{
+	t_tmbk *this = RTYPEDDATA_DATA( self );
+
+	return rb_hash_lookup(this->klass_to_coder, klass);
+}
+
+/*
+ * call-seq:
+ *    typemap.coders -> Hash
+ *
+ * Returns all classes and their assigned encoder object.
+ */
+static VALUE
+pg_tmbk_coders( VALUE self )
+{
+	t_tmbk *this = RTYPEDDATA_DATA( self );
+
+	return rb_obj_freeze(rb_hash_dup(this->klass_to_coder));
+}
+
+void
+init_pg_type_map_by_class()
+{
+	/*
+	 * Document-class: PG::TypeMapByClass < PG::TypeMap
+	 *
+	 * This type map casts values based on the class or the ancestors 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_cTypeMapByClass = rb_define_class_under( rb_mPG, "TypeMapByClass", rb_cTypeMap );
+	rb_define_alloc_func( rb_cTypeMapByClass, pg_tmbk_s_allocate );
+	rb_define_method( rb_cTypeMapByClass, "[]=", pg_tmbk_aset, 2 );
+	rb_define_method( rb_cTypeMapByClass, "[]", pg_tmbk_aref, 1 );
+	rb_define_method( rb_cTypeMapByClass, "coders", pg_tmbk_coders, 0 );
+	/* rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable"); */
+	rb_include_module( rb_cTypeMapByClass, rb_mDefaultTypeMappable );
+}