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

data/ext/pg_text_encoder.c

@@ -42,6 +42,7 @@
 #include "pg.h"
 #include "util.h"
 #include <inttypes.h>
+#include <math.h>
 
 VALUE rb_mPG_TextEncoder;
 static ID s_id_encode;
@@ -246,6 +247,46 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 	}
 }
 
+static const char hextab[] = {
+	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+};
+
+/*
+ * Document-class: PG::TextEncoder::Bytea < PG::SimpleEncoder
+ *
+ * This is an encoder class for the PostgreSQL bytea type for server version 9.0
+ * or newer.
+ *
+ * The binary String is converted to hexadecimal representation for transmission
+ * in text format. For query bind parameters it is recommended to use
+ * PG::BinaryEncoder::Bytea instead, in order to decrease network traffic and
+ * CPU usage.
+ *
+ */
+static int
+pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	if(out){
+		size_t strlen = RSTRING_LEN(*intermediate);
+		char *iptr = RSTRING_PTR(*intermediate);
+		char *eptr = iptr + strlen;
+		char *optr = out;
+		*optr++ = '\\';
+		*optr++ = 'x';
+
+		for( ; iptr < eptr; iptr++ ){
+			unsigned char c = *iptr;
+			*optr++ = hextab[c >> 4];
+			*optr++ = hextab[c & 0xf];
+		}
+		return optr - out;
+	}else{
+		*intermediate = rb_obj_as_string(value);
+		/* The output starts with "\x" and each character is converted to hex. */
+		return 2 + RSTRING_LEN(*intermediate) * 2;
+	}
+}
+
 typedef int (*t_quote_func)( void *_this, char *p_in, int strlen, char *p_out );
 
 static int
@@ -619,6 +660,8 @@ init_pg_text_encoder()
 	pg_define_coder( "Float", pg_text_enc_float, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "String", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "String", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Bytea", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Bytea", pg_text_enc_bytea, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Array", rb_cPG_CompositeEncoder ); */
 	pg_define_coder( "Array", pg_text_enc_array, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );

data/ext/pg_type_map.c

@@ -7,6 +7,7 @@
 #include "pg.h"
 
 VALUE rb_cTypeMap;
+VALUE rb_mDefaultTypeMappable;
 static ID s_id_fit_to_query;
 static ID s_id_fit_to_result;
 
@@ -27,31 +28,40 @@ pg_typemap_fit_to_query( VALUE self, VALUE params )
 int
 pg_typemap_fit_to_copy_get( VALUE self )
 {
-	rb_raise( rb_eNotImpError, "type map %s is not suitable to map copy_get_data results", rb_obj_classname(self) );
+	rb_raise( rb_eNotImpError, "type map %s is not suitable to map get_copy_data results", rb_obj_classname(self) );
 	return Qnil;
 }
 
 VALUE
-pg_typemap_result_value(VALUE self, int tuple, int field)
+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" );
 	return Qnil;
 }
 
 t_pg_coder *
-pg_typemap_typecast_query_param(VALUE self, VALUE param_value, int field)
+pg_typemap_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 {
-	rb_raise( rb_eNotImpError, "type map %s is not suitable to map query params", rb_obj_classname(self) );
+	rb_raise( rb_eNotImpError, "type map is not suitable to map query params" );
 	return NULL;
 }
 
 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 copy_get_data results" );
+	rb_raise( rb_eNotImpError, "type map is not suitable to map get_copy_data results" );
 	return Qnil;
 }
 
+const struct pg_typemap_funcs pg_typemap_funcs = {
+	.fit_to_result = pg_typemap_fit_to_result,
+	.fit_to_query = pg_typemap_fit_to_query,
+	.fit_to_copy_get = pg_typemap_fit_to_copy_get,
+	.typecast_result_value = pg_typemap_result_value,
+	.typecast_query_param = pg_typemap_typecast_query_param,
+	.typecast_copy_get = pg_typemap_typecast_copy_get
+};
+
 static VALUE
 pg_typemap_s_allocate( VALUE klass )
 {
@@ -59,12 +69,7 @@ pg_typemap_s_allocate( VALUE klass )
 	t_typemap *this;
 
 	self = Data_Make_Struct( klass, t_typemap, NULL, -1, this );
-	this->fit_to_result = pg_typemap_fit_to_result;
-	this->fit_to_query = pg_typemap_fit_to_query;
-	this->fit_to_copy_get = pg_typemap_fit_to_copy_get;
-	this->typecast_result_value = pg_typemap_result_value;
-	this->typecast_query_param = pg_typemap_typecast_query_param;
-	this->typecast_copy_get = pg_typemap_typecast_copy_get;
+	this->funcs = pg_typemap_funcs;
 
 	return self;
 }
@@ -79,7 +84,7 @@ pg_typemap_fit_to_result_ext( VALUE self, VALUE result )
 				rb_obj_classname( result ) );
 	}
 
-	return this->fit_to_result( self, result );
+	return this->funcs.fit_to_result( self, result );
 }
 
 static VALUE
@@ -89,7 +94,68 @@ pg_typemap_fit_to_query_ext( VALUE self, VALUE params )
 
 	Check_Type( params, T_ARRAY);
 
-	return this->fit_to_query( self, params );
+	return this->funcs.fit_to_query( self, params );
+}
+
+/*
+ * 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 = DATA_PTR( self );
+
+	if ( !rb_obj_is_kind_of(typemap, rb_cTypeMap) ) {
+		rb_raise( rb_eTypeError, "wrong argument type %s (expected kind of PG::TypeMap)",
+				rb_obj_classname( typemap ) );
+	}
+	Check_Type(typemap, T_DATA);
+	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 = DATA_PTR( 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
@@ -110,4 +176,9 @@ init_pg_type_map()
 	rb_define_alloc_func( rb_cTypeMap, pg_typemap_s_allocate );
 	rb_define_method( rb_cTypeMap, "fit_to_result", pg_typemap_fit_to_result_ext, 1 );
 	rb_define_method( rb_cTypeMap, "fit_to_query", pg_typemap_fit_to_query_ext, 1 );
+
+	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

@@ -9,7 +9,7 @@
 #include "pg.h"
 
 VALUE rb_cTypeMapAllStrings;
-VALUE pg_default_typemap;
+VALUE pg_typemap_all_strings;
 
 static VALUE
 pg_tmas_fit_to_result( VALUE self, VALUE result )
@@ -18,7 +18,7 @@ pg_tmas_fit_to_result( VALUE self, VALUE result )
 }
 
 static VALUE
-pg_tmas_result_value(VALUE result, int tuple, int field)
+pg_tmas_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 {
 	VALUE ret;
 	char * val;
@@ -48,7 +48,7 @@ pg_tmas_fit_to_query( VALUE self, VALUE params )
 }
 
 static t_pg_coder *
-pg_tmas_typecast_query_param(VALUE self, VALUE param_value, int field)
+pg_tmas_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 {
 	return NULL;
 }
@@ -79,12 +79,12 @@ pg_tmas_s_allocate( VALUE klass )
 
 	self = Data_Make_Struct( klass, t_typemap, NULL, -1, this );
 
-	this->fit_to_result = pg_tmas_fit_to_result;
-	this->fit_to_query = pg_tmas_fit_to_query;
-	this->fit_to_copy_get = pg_tmas_fit_to_copy_get;
-	this->typecast_result_value = pg_tmas_result_value;
-	this->typecast_query_param = pg_tmas_typecast_query_param;
-	this->typecast_copy_get = pg_tmas_typecast_copy_get;
+	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;
 }
@@ -98,16 +98,19 @@ init_pg_type_map_all_strings()
 	 *
 	 * 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_str+ .
+	 * That means, it is hard coded to PG::TextEncoder::String for value encoding
+	 * and to PG::TextDecoder::String for text format respectivly 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. It is used when type_map is not set or set to +nil+.
+	 * 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_default_typemap = rb_funcall( rb_cTypeMapAllStrings, rb_intern("new"), 0 );
-	rb_gc_register_address( &pg_default_typemap );
+	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,239 @@
+/*
+ * 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;
+static ID s_id_ancestors;
+
+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[(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_funcall( klass, s_id_ancestors, 0 );
+
+			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)){
+			Data_Get_Struct(obj, t_pg_coder, p_coder);
+		}else{
+			if( RB_TYPE_P(obj, T_SYMBOL) ){
+				/* A Proc object (or something that responds to #call). */
+				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 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 has invalid type %s (should be nil or some kind of PG::Coder)",
+							rb_obj_classname( obj ));
+			}
+
+			/* 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 = DATA_PTR( 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 *)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;
+}
+
+static void
+pg_tmbk_mark( t_tmbk *this )
+{
+	rb_gc_mark(this->typemap.default_typemap);
+	rb_gc_mark(this->klass_to_coder);
+	/* All coders are in the Hash, so no need to mark the cache. */
+}
+
+static VALUE
+pg_tmbk_s_allocate( VALUE klass )
+{
+	t_tmbk *this;
+	VALUE self;
+
+	self = Data_Make_Struct( klass, t_tmbk, pg_tmbk_mark, -1, 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 Data_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 = DATA_PTR( 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 = DATA_PTR( 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 = DATA_PTR( self );
+
+	return rb_obj_freeze(rb_hash_dup(this->klass_to_coder));
+}
+
+void
+init_pg_type_map_by_class()
+{
+	s_id_ancestors = rb_intern("ancestors");
+
+	/*
+	 * 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_include_module( rb_cTypeMapByClass, rb_mDefaultTypeMappable );
+}