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

data/ext/pg_text_decoder.c

@@ -313,8 +313,8 @@ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int fiel
 	VALUE elem;
 	int word_index = 0;
 	int index;
-	/* create a buffer of the same length, as that will be the worst case */
-	char *word = xmalloc(len + 1);
+	/* Use a buffer of the same length, as that will be the worst case */
+	char word[len + 1];
 
 	/* The current character in the input string. */
 	char c;
@@ -356,8 +356,6 @@ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int fiel
 	elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
 	rb_ary_push(array, elem);
 
-	free(word);
-
 	return array;
 }
 

data/ext/pg_text_encoder.c

@@ -47,8 +47,8 @@
 VALUE rb_mPG_TextEncoder;
 static ID s_id_encode;
 static ID s_id_to_i;
-static VALUE hash_false_values;
 
+static int pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate);
 
 VALUE
 pg_obj_to_i( VALUE value )
@@ -68,38 +68,37 @@ pg_obj_to_i( VALUE value )
  *
  * This is the encoder class for the PostgreSQL bool type.
  *
- * Ruby values false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off' and 'OFF'
- * are encoded as SQL +FALSE+ value. nil is sent as SQL +NULL+.
- * Any other values are encoded as SQL +TRUE+ .
+ * Ruby value false is encoded as SQL +FALSE+ value.
+ * Ruby value true is encoded as SQL +TRUE+ value.
+ * Any other value is sent as it's string representation.
  *
  */
 static int
-pg_text_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_boolean(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
 {
-	if(out){
-		switch( TYPE(value) ){
-			case T_FALSE:
-				*out = 'f';
-				break;
-			case T_FIXNUM:
-			case T_BIGNUM:
-				if( NUM2LONG(value) == 0 ){
-					*out = 'f';
-				} else {
-					*out = 't';
-				}
-				break;
-			case T_STRING:
-				if( rb_hash_lookup(hash_false_values, value) == Qtrue ){
-					*out = 'f';
-					break;
-				}
-				/* fall through */
-			default:
-				*out = 't';
-		}
+	switch( TYPE(value) ){
+		case T_FALSE:
+			if(out) *out = 'f';
+			return 1;
+		case T_TRUE:
+			if(out) *out = 't';
+			return 1;
+		case T_FIXNUM:
+		case T_BIGNUM:
+			if( NUM2LONG(value) == 0 ){
+				if(out) *out = '0';
+				return 1;
+			} else if( NUM2LONG(value) == 1 ){
+				if(out) *out = '1';
+				return 1;
+			} else {
+				return pg_text_enc_integer(this, value, out, intermediate);
+			}
+		default:
+			return pg_coder_enc_to_s(this, value, out, intermediate);
 	}
-	return 1;
+	/* never reached */
+	return 0;
 }
 
 
@@ -638,16 +637,6 @@ init_pg_text_encoder()
 	s_id_encode = rb_intern("encode");
 	s_id_to_i = rb_intern("to_i");
 
-	hash_false_values = rb_hash_new();
-	rb_gc_register_address( &hash_false_values );
-	rb_hash_aset( hash_false_values, rb_str_new2( "0" ), Qtrue );
-	rb_hash_aset( hash_false_values, rb_str_new2( "f" ), Qtrue );
-	rb_hash_aset( hash_false_values, rb_str_new2( "F" ), Qtrue );
-	rb_hash_aset( hash_false_values, rb_str_new2( "false" ), Qtrue );
-	rb_hash_aset( hash_false_values, rb_str_new2( "FALSE" ), Qtrue );
-	rb_hash_aset( hash_false_values, rb_str_new2( "off" ), Qtrue );
-	rb_hash_aset( hash_false_values, rb_str_new2( "OFF" ), Qtrue );
-
 	/* This module encapsulates all encoder classes with text output format */
 	rb_mPG_TextEncoder = rb_define_module_under( rb_mPG, "TextEncoder" );
 

data/ext/pg_type_map.c

@@ -74,29 +74,6 @@ pg_typemap_s_allocate( VALUE klass )
 	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->funcs.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->funcs.fit_to_query( self, params );
-}
-
 /*
  * call-seq:
  *    res.default_type_map = typemap
@@ -174,8 +151,6 @@ init_pg_type_map()
 	 */
 	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 );
 
 	rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable");
 	rb_define_method( rb_mDefaultTypeMappable, "default_type_map=", pg_typemap_default_type_map_set, 1 );

data/ext/pg_type_map_all_strings.c

@@ -97,7 +97,7 @@ 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+ .
+	 * 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 respectivly PG::BinaryDecoder::Bytea
 	 * for binary format received from the server.

data/ext/pg_type_map_by_oid.c

@@ -130,7 +130,7 @@ pg_tmbo_fit_to_result( VALUE self, VALUE result )
 	if( PQntuples( pgresult ) <= this->max_rows_for_online_lookup ){
 		/* Do a hash lookup for each result value in pg_tmbc_result_value() */
 
-	/* Did the default type return the same object ? */
+		/* Did the default type return the same object ? */
 		if( sub_typemap == this->typemap.default_typemap ){
 			return self;
 		} else {
@@ -306,41 +306,23 @@ pg_tmbo_max_rows_for_online_lookup_get( VALUE self )
 
 /*
  * 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 ).
+ *    typemap.build_column_map( result )
  *
+ * This builds a PG::TypeMapByColumn that fits to the given PG::Result object
+ * based on it's type OIDs.
  *
  */
 static VALUE
-pg_tmbo_fit_to_result_ext( int argc, VALUE *argv, VALUE self )
+pg_tmbo_build_column_map( VALUE self, VALUE result )
 {
 	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.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 ) ){
-		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 ) );
-	}
+	return pg_tmbo_build_type_map_for_result2( this, pgresult_get(result) );
 }
 
 
@@ -368,6 +350,6 @@ init_pg_type_map_by_oid()
 	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 );
+	rb_define_method( rb_cTypeMapByOid, "build_column_map", pg_tmbo_build_column_map, 1 );
 	rb_include_module( rb_cTypeMapByOid, rb_mDefaultTypeMappable );
 }

data/ext/pg_type_map_in_ruby.c

@@ -0,0 +1,302 @@
+/*
+ * pg_type_map_in_ruby.c - PG::TypeMapInRuby class extension
+ * $Id$
+ *
+ */
+
+#include "pg.h"
+
+VALUE rb_cTypeMapInRuby;
+static VALUE s_id_fit_to_result;
+static VALUE s_id_fit_to_query;
+static VALUE s_id_fit_to_copy_get;
+static VALUE s_id_typecast_result_value;
+static VALUE s_id_typecast_query_param;
+static VALUE s_id_typecast_copy_get;
+
+typedef struct {
+	t_typemap typemap;
+	VALUE self;
+} t_tmir;
+
+
+/*
+ * call-seq:
+ *    typemap.fit_to_result( result )
+ *
+ * Check that the type map fits to the result.
+ *
+ * This method is called, when a type map is assigned to a result.
+ * It must return a PG::TypeMap object or raise an Exception.
+ * This can be +self+ or some other type map that fits to the result.
+ *
+ */
+static VALUE
+pg_tmir_fit_to_result( VALUE self, VALUE result )
+{
+	t_tmir *this = DATA_PTR( self );
+	t_typemap *default_tm;
+	t_typemap *p_new_typemap;
+	VALUE sub_typemap;
+	VALUE new_typemap;
+
+	if( rb_respond_to(self, s_id_fit_to_result) ){
+		new_typemap = rb_funcall( self, s_id_fit_to_result, 1, result );
+
+		if ( !rb_obj_is_kind_of(new_typemap, rb_cTypeMap) ) {
+			rb_raise( rb_eTypeError, "wrong return type from fit_to_result: %s expected kind of PG::TypeMap",
+					rb_obj_classname( new_typemap ) );
+		}
+		Check_Type( new_typemap, T_DATA );
+	} else {
+		new_typemap = 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 );
+
+	if( sub_typemap != this->typemap.default_typemap ){
+		new_typemap = rb_obj_dup( new_typemap );
+	}
+
+	p_new_typemap = DATA_PTR(new_typemap);
+	p_new_typemap->default_typemap = sub_typemap;
+	return new_typemap;
+}
+
+static VALUE
+pg_tmir_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
+{
+	t_tmir *this = (t_tmir *) p_typemap;
+
+	return rb_funcall( this->self, s_id_typecast_result_value, 3, result, INT2NUM(tuple), INT2NUM(field) );
+}
+
+/*
+ * call-seq:
+ *    typemap.typecast_result_value( result, tuple, field )
+ *
+ * Retrieve and cast a field of the given result.
+ *
+ * This method implementation uses the #default_type_map to get the
+ * field value. It can be derived to change this behaviour.
+ *
+ * Parameters:
+ * * +result+ : The PG::Result received from the database.
+ * * +tuple+ : The row number to retrieve.
+ * * +field+ : The column number to retrieve.
+ *
+ * Note: Calling any value retrieving methods of +result+ will result
+ * in an (endless) recursion. Instead super() can be used to retrieve
+ * the value using the default_typemap.
+ *
+ */
+static VALUE
+pg_tmir_typecast_result_value( VALUE self, VALUE result, VALUE tuple, VALUE field )
+{
+	t_tmir *this = DATA_PTR( self );
+	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	return default_tm->funcs.typecast_result_value( default_tm, result, NUM2INT(tuple), NUM2INT(field) );
+}
+
+/*
+ * call-seq:
+ *    typemap.fit_to_query( params )
+ *
+ * Check that the type map fits to the given user values.
+ *
+ * This method is called, when a type map is used for sending a query
+ * and for encoding of copy data, before the value is casted.
+ *
+ */
+static VALUE
+pg_tmir_fit_to_query( VALUE self, VALUE params )
+{
+	t_tmir *this = DATA_PTR( self );
+	t_typemap *default_tm;
+
+	if( rb_respond_to(self, s_id_fit_to_query) ){
+		rb_funcall( self, s_id_fit_to_query, 1, params );
+	}
+
+	/* 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;
+}
+
+static t_pg_coder *
+pg_tmir_query_param( t_typemap *p_typemap, VALUE param_value, int field )
+{
+	t_tmir *this = (t_tmir *) p_typemap;
+
+	VALUE coder = rb_funcall( this->self, s_id_typecast_query_param, 2, param_value, INT2NUM(field) );
+
+	if ( NIL_P(coder) ){
+		return NULL;
+	} else if( rb_obj_is_kind_of(coder, rb_cPG_Coder) ) {
+		return DATA_PTR(coder);
+	} else {
+		rb_raise( rb_eTypeError, "wrong return type from typecast_query_param: %s expected nil or kind of PG::Coder",
+				rb_obj_classname( coder ) );
+	}
+}
+
+/*
+ * call-seq:
+ *    typemap.typecast_query_param( param_value, field )
+ *
+ * Cast a field string for transmission to the server.
+ *
+ * This method implementation uses the #default_type_map to cast param_value.
+ * It can be derived to change this behaviour.
+ *
+ * Parameters:
+ * * +param_value+ : The value from the user.
+ * * +field+ : The field number from left to right.
+ *
+ */
+static VALUE
+pg_tmir_typecast_query_param( VALUE self, VALUE param_value, VALUE field )
+{
+	t_tmir *this = DATA_PTR( self );
+	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	t_pg_coder *p_coder = default_tm->funcs.typecast_query_param( default_tm, param_value, NUM2INT(field) );
+
+	return p_coder ? p_coder->coder_obj : Qnil;
+}
+
+/* This is to fool rdoc's C parser */
+#if 0
+/*
+ * call-seq:
+ *    typemap.fit_to_copy_get()
+ *
+ * Check that the type map can be used for PG::Connection#get_copy_data.
+ *
+ * This method is called, when a type map is used for decoding copy data,
+ * before the value is casted.
+ *
+ */
+static VALUE pg_tmir_fit_to_copy_get_dummy( VALUE self ){}
+#endif
+
+static int
+pg_tmir_fit_to_copy_get( VALUE self )
+{
+	t_tmir *this = DATA_PTR( self );
+	t_typemap *default_tm;
+	VALUE num_columns = INT2NUM(0);
+
+	if( rb_respond_to(self, s_id_fit_to_copy_get) ){
+		num_columns = rb_funcall( self, s_id_fit_to_copy_get, 0 );
+	}
+
+	if ( !rb_obj_is_kind_of(num_columns, rb_cInteger) ) {
+		rb_raise( rb_eTypeError, "wrong return type from fit_to_copy_get: %s expected kind of Integer",
+				rb_obj_classname( num_columns ) );
+	}
+	/* Ensure that the default type map fits equaly. */
+	default_tm = DATA_PTR( this->typemap.default_typemap );
+	default_tm->funcs.fit_to_copy_get( this->typemap.default_typemap );
+
+	return NUM2INT(num_columns);;
+}
+
+static VALUE
+pg_tmir_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
+{
+	t_tmir *this = (t_tmir *) p_typemap;
+	rb_encoding *p_encoding = rb_enc_from_index(enc_idx);
+	VALUE enc = rb_enc_from_encoding(p_encoding);
+	/* field_str is reused in-place by pg_text_dec_copy_row(), so we need to make
+	 * a copy of the string buffer before used in ruby space.
+	 * This requires rb_str_new() instead of rb_str_dup() for Rubinius.
+	 */
+	VALUE field_str_copy = rb_str_new(RSTRING_PTR(field_str), RSTRING_LEN(field_str));
+	PG_ENCODING_SET_NOCHECK(field_str_copy, ENCODING_GET(field_str));
+	OBJ_INFECT(field_str_copy, field_str);
+
+	return rb_funcall( this->self, s_id_typecast_copy_get, 4, field_str_copy, INT2NUM(fieldno), INT2NUM(format), enc );
+}
+
+/*
+ * call-seq:
+ *    typemap.typecast_copy_get( field_str, fieldno, format, encoding )
+ *
+ * Cast a field string received by PG::Connection#get_copy_data.
+ *
+ * This method implementation uses the #default_type_map to cast field_str.
+ * It can be derived to change this behaviour.
+ *
+ * Parameters:
+ * * +field_str+ : The String received from the server.
+ * * +fieldno+ : The field number from left to right.
+ * * +format+ : The format code (0 = text, 1 = binary)
+ * * +encoding+ : The encoding of the connection and encoding the returned
+ *   value should get.
+ *
+ */
+static VALUE
+pg_tmir_typecast_copy_get( VALUE self, VALUE field_str, VALUE fieldno, VALUE format, VALUE enc )
+{
+	t_tmir *this = DATA_PTR( self );
+	t_typemap *default_tm = DATA_PTR( this->typemap.default_typemap );
+	int enc_idx = rb_to_encoding_index( enc );
+
+	return default_tm->funcs.typecast_copy_get( default_tm, field_str, NUM2INT(fieldno), NUM2INT(format), enc_idx );
+}
+
+static VALUE
+pg_tmir_s_allocate( VALUE klass )
+{
+	t_tmir *this;
+	VALUE self;
+
+	self = Data_Make_Struct( klass, t_tmir, NULL, -1, this );
+
+	this->typemap.funcs.fit_to_result = pg_tmir_fit_to_result;
+	this->typemap.funcs.fit_to_query = pg_tmir_fit_to_query;
+	this->typemap.funcs.fit_to_copy_get = pg_tmir_fit_to_copy_get;
+	this->typemap.funcs.typecast_result_value = pg_tmir_result_value;
+	this->typemap.funcs.typecast_query_param = pg_tmir_query_param;
+	this->typemap.funcs.typecast_copy_get = pg_tmir_copy_get;
+	this->typemap.default_typemap = pg_typemap_all_strings;
+	this->self = self;
+
+	return self;
+}
+
+
+void
+init_pg_type_map_in_ruby()
+{
+	s_id_fit_to_result = rb_intern("fit_to_result");
+	s_id_fit_to_query = rb_intern("fit_to_query");
+	s_id_fit_to_copy_get = rb_intern("fit_to_copy_get");
+	s_id_typecast_result_value = rb_intern("typecast_result_value");
+	s_id_typecast_query_param = rb_intern("typecast_query_param");
+	s_id_typecast_copy_get = rb_intern("typecast_copy_get");
+
+	/*
+	 * Document-class: PG::TypeMapInRuby < PG::TypeMap
+	 *
+	 * This class can be used to implement a type map in ruby, typically as a
+	 * #default_type_map in a type map chain.
+	 *
+	 * This API is EXPERIMENTAL and could change in the future.
+	 *
+	 */
+	rb_cTypeMapInRuby = rb_define_class_under( rb_mPG, "TypeMapInRuby", rb_cTypeMap );
+	rb_define_alloc_func( rb_cTypeMapInRuby, pg_tmir_s_allocate );
+	/* rb_define_method( rb_cTypeMapInRuby, "fit_to_result", pg_tmir_fit_to_result, 1 ); */
+	/* rb_define_method( rb_cTypeMapInRuby, "fit_to_query", pg_tmir_fit_to_query, 1 ); */
+	/* rb_define_method( rb_cTypeMapInRuby, "fit_to_copy_get", pg_tmir_fit_to_copy_get_dummy, 0 ); */
+	rb_define_method( rb_cTypeMapInRuby, "typecast_result_value", pg_tmir_typecast_result_value, 3 );
+	rb_define_method( rb_cTypeMapInRuby, "typecast_query_param", pg_tmir_typecast_query_param, 2 );
+	rb_define_method( rb_cTypeMapInRuby, "typecast_copy_get", pg_tmir_typecast_copy_get, 4 );
+	/* rb_mDefaultTypeMappable = rb_define_module_under( rb_cTypeMap, "DefaultTypeMappable"); */
+	rb_include_module( rb_cTypeMapInRuby, rb_mDefaultTypeMappable );
+}