pg 0.18.0.pre20140820094244 → 0.18.0.pre20141017155815

data/ext/pg_type_map.c

@@ -0,0 +1,113 @@
+/*
+ * pg_column_map.c - PG::ColumnMap class extension
+ * $Id: pg_type_map.c,v 4227fdc5f0ac 2014/10/07 17:42:09 lars $
+ *
+ */
+
+#include "pg.h"
+
+VALUE rb_cTypeMap;
+static ID s_id_fit_to_query;
+static ID s_id_fit_to_result;
+
+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) );
+	return Qnil;
+}
+
+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) );
+	return Qnil;
+}
+
+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) );
+	return Qnil;
+}
+
+VALUE
+pg_typemap_result_value(VALUE self, 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)
+{
+	rb_raise( rb_eNotImpError, "type map %s is not suitable to map query params", rb_obj_classname(self) );
+	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" );
+	return Qnil;
+}
+
+static VALUE
+pg_typemap_s_allocate( VALUE klass )
+{
+	VALUE self;
+	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;
+
+	return self;
+}
+
+static VALUE
+pg_typemap_fit_to_result_ext( VALUE self, VALUE result )
+{
+	t_typemap *this = DATA_PTR( 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 this->fit_to_result( self, result );
+}
+
+static VALUE
+pg_typemap_fit_to_query_ext( VALUE self, VALUE params )
+{
+	t_typemap *this = DATA_PTR( self );
+
+	Check_Type( params, T_ARRAY);
+
+	return this->fit_to_query( self, params );
+}
+
+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_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 );
+}

data/ext/pg_type_map_all_strings.c

@@ -0,0 +1,113 @@
+/*
+ * pg_type_map_all_strings.c - PG::TypeMapAllStrings class extension
+ * $Id: pg_type_map_all_strings.c,v 4227fdc5f0ac 2014/10/07 17:42:09 lars $
+ *
+ * This is the default typemap.
+ *
+ */
+
+#include "pg.h"
+
+VALUE rb_cTypeMapAllStrings;
+VALUE pg_default_typemap;
+
+static VALUE
+pg_tmas_fit_to_result( VALUE self, VALUE result )
+{
+	return self;
+}
+
+static VALUE
+pg_tmas_result_value(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, ENCODING_GET(result));
+	} else {
+		ret = pg_bin_dec_bytea(NULL, val, len, tuple, field, ENCODING_GET(result));
+	}
+
+	return ret;
+}
+
+static VALUE
+pg_tmas_fit_to_query( VALUE self, VALUE params )
+{
+	return self;
+}
+
+static t_pg_coder *
+pg_tmas_typecast_query_param(VALUE self, 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 = 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;
+
+	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_str+ .
+	 *
+	 * 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+.
+	 *
+	 */
+	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 );
+}

data/ext/pg_type_map_by_column.c

@@ -0,0 +1,254 @@
+/*
+ * pg_column_map.c - PG::ColumnMap class extension
+ * $Id: pg_type_map_by_column.c,v ec9ef7fb39eb 2014/10/10 18:59:10 lars $
+ *
+ */
+
+#include "pg.h"
+
+static VALUE rb_cTypeMapByColumn;
+static ID s_id_decode;
+static ID s_id_encode;
+
+static VALUE
+pg_tmbc_fit_to_result( VALUE self, VALUE result )
+{
+	int nfields;
+	t_tmbc *this = DATA_PTR( self );
+
+	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;
+}
+
+static VALUE
+pg_tmbc_fit_to_query( VALUE self, VALUE params )
+{
+	int nfields;
+	t_tmbc *this = DATA_PTR( self );
+
+	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 );
+	}
+	return self;
+}
+
+static int
+pg_tmbc_fit_to_copy_get( VALUE self )
+{
+	t_tmbc *this = DATA_PTR( self );
+	return this->nfields;
+}
+
+
+VALUE
+pg_tmbc_result_value(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;
+
+	if (PQgetisnull(p_result->pgresult, tuple, field)) {
+		return Qnil;
+	}
+
+	val = PQgetvalue( p_result->pgresult, tuple, field );
+	len = PQgetlength( p_result->pgresult, tuple, field );
+
+	if( this ){
+		p_coder = this->convs[field].cconv;
+
+		if( p_coder && p_coder->dec_func ){
+			return p_coder->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) );
+}
+
+static t_pg_coder *
+pg_tmbc_typecast_query_param(VALUE self, VALUE param_value, int field)
+{
+	t_tmbc *this = (t_tmbc *)DATA_PTR(self);
+
+	/* Number of fields were already checked in pg_tmbc_fit_to_query() */
+	t_pg_coder *p_coder = this->convs[field].cconv;
+
+	return p_coder;
+}
+
+static VALUE
+pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
+{
+	t_tmbc *this = (t_tmbc *) p_typemap;
+	t_pg_coder *p_coder;
+	t_pg_coder_dec_func dec_func;
+
+	if ( fieldno >= this->nfields || fieldno < 0 ) {
+		rb_raise( rb_eArgError, "number of copy fields (%d) exceeds number of mapped columns (%d)",
+				fieldno, this->nfields );
+	}
+
+	p_coder = this->convs[fieldno].cconv;
+
+	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 ){
+		PG_ENCODING_SET_NOCHECK( field_str, enc_idx );
+		return field_str;
+	}
+	if( format == 1 && dec_func == pg_bin_dec_bytea ){
+		PG_ENCODING_SET_NOCHECK( field_str, rb_ascii8bit_encindex() );
+		return field_str;
+	}
+
+	return dec_func( p_coder, RSTRING_PTR(field_str), RSTRING_LEN(field_str), 0, fieldno, enc_idx );
+}
+
+const t_typemap pg_tmbc_default_typemap = {
+	.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,
+	.typecast_result_value = pg_tmbc_result_value,
+	.typecast_query_param = pg_tmbc_typecast_query_param,
+	.typecast_copy_get = pg_tmbc_typecast_copy_get
+};
+
+static void
+pg_tmbc_mark( t_tmbc *this )
+{
+	int i;
+
+	/* allocated but not initialized ? */
+	if( !this ) return;
+
+	for( i=0; i<this->nfields; i++){
+		t_pg_coder *p_coder = this->convs[i].cconv;
+		if( p_coder )
+			rb_gc_mark(p_coder->coder_obj);
+	}
+}
+
+static VALUE
+pg_tmbc_s_allocate( VALUE klass )
+{
+	return Data_Wrap_Struct( klass, pg_tmbc_mark, -1, NULL );
+}
+
+VALUE
+pg_tmbc_allocate()
+{
+	return pg_tmbc_s_allocate(rb_cTypeMapByColumn);
+}
+
+/*
+ * call-seq:
+ *    PG::TypeMapByColumn.new( coders )
+ *
+ * Builds a new type map and assigns a list of coders for the given column.
+ * +coders+ must be an Array of PG::Coder objects or +nil+ values.
+ * 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.
+ */
+static VALUE
+pg_tmbc_init(VALUE self, VALUE conv_ary)
+{
+	int i;
+	t_tmbc *this;
+	int conv_ary_len;
+
+	Check_Type(self, T_DATA);
+	Check_Type(conv_ary, T_ARRAY);
+	conv_ary_len = RARRAY_LEN(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;
+	DATA_PTR(self) = this;
+
+	for(i=0; i<conv_ary_len; i++)
+	{
+		VALUE obj = rb_ary_entry(conv_ary, i);
+
+		if( obj == Qnil ){
+			/* no type cast */
+			this->convs[i].cconv = NULL;
+		} else if( rb_obj_is_kind_of(obj, rb_cPG_Coder) ){
+			Data_Get_Struct(obj, t_pg_coder, this->convs[i].cconv);
+		} else {
+			rb_raise(rb_eArgError, "argument %d has invalid type %s (should be nil or some kind of PG::Coder)",
+							 i+1, rb_obj_classname( obj ));
+		}
+	}
+
+	this->nfields = conv_ary_len;
+
+	return self;
+}
+
+/*
+ * call-seq:
+ *    typemap.coders -> Array
+ *
+ * Array of PG::Coder objects. The length of the Array corresponds to
+ * the number of columns or bind parameters this type map is usable for.
+ */
+static VALUE
+pg_tmbc_coders(VALUE self)
+{
+	int i;
+	t_tmbc *this = DATA_PTR( self );
+	VALUE ary_coders = rb_ary_new();
+
+	for( i=0; i<this->nfields; i++){
+		t_pg_coder *conv = this->convs[i].cconv;
+		if( conv ) {
+			rb_ary_push( ary_coders, conv->coder_obj );
+		} else {
+			rb_ary_push( ary_coders, Qnil );
+		}
+	}
+
+	return rb_obj_freeze(ary_coders);
+}
+
+void
+init_pg_type_map_by_column()
+{
+	s_id_decode = rb_intern("decode");
+	s_id_encode = rb_intern("encode");
+
+	/*
+	 * Document-class: PG::TypeMapByColumn < PG::TypeMap
+	 *
+	 * This type map casts values by a coder assigned per field/column.
+	 *
+	 * Each PG:TypeMapByColumn has a fixed list of either encoders or decoders,
+	 * that is defined at #new . A type map with encoders is usable for type casting
+	 * query bind parameters and COPY data for PG::Connection#put_copy_data .
+	 * A type map with decoders is usable for type casting of result values and
+	 * COPY data from PG::Connection#get_copy_data .
+	 *
+	 * PG::TypeMapByColumns are in particular useful in conjunction with prepared statements,
+	 * since they can be cached alongside with the statement handle.
+	 *
+	 * This type map strategy is also used internally by PG::TypeMapByOid, when the
+	 * number of rows of a result set exceeds a given limit.
+	 */
+	rb_cTypeMapByColumn = rb_define_class_under( rb_mPG, "TypeMapByColumn", rb_cTypeMap );
+	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 );
+}