pg 1.2.3 → 1.5.4

data/ext/pg_result.c

@@ -107,17 +107,34 @@ pgresult_approx_size(const PGresult *result)
  * GC Mark function
  */
 static void
-pgresult_gc_mark( t_pg_result *this )
+pgresult_gc_mark( void *_this )
 {
+	t_pg_result *this = (t_pg_result *)_this;
 	int i;
 
-	rb_gc_mark( this->connection );
-	rb_gc_mark( this->typemap );
-	rb_gc_mark( this->tuple_hash );
-	rb_gc_mark( this->field_map );
+	rb_gc_mark_movable( this->connection );
+	rb_gc_mark_movable( this->typemap );
+	rb_gc_mark_movable( this->tuple_hash );
+	rb_gc_mark_movable( this->field_map );
 
 	for( i=0; i < this->nfields; i++ ){
-		rb_gc_mark( this->fnames[i] );
+		rb_gc_mark_movable( this->fnames[i] );
+	}
+}
+
+static void
+pgresult_gc_compact( void *_this )
+{
+	t_pg_result *this = (t_pg_result *)_this;
+	int i;
+
+	pg_gc_location( this->connection );
+	pg_gc_location( this->typemap );
+	pg_gc_location( this->tuple_hash );
+	pg_gc_location( this->field_map );
+
+	for( i=0; i < this->nfields; i++ ){
+		pg_gc_location( this->fnames[i] );
 	}
 }
 
@@ -125,8 +142,9 @@ pgresult_gc_mark( t_pg_result *this )
  * GC Free function
  */
 static void
-pgresult_clear( t_pg_result *this )
+pgresult_clear( void *_this )
 {
+	t_pg_result *this = (t_pg_result *)_this;
 	if( this->pgresult && !this->autoclear ){
 		PQclear(this->pgresult);
 #ifdef HAVE_RB_GC_ADJUST_MEMORY_USAGE
@@ -139,15 +157,17 @@ pgresult_clear( t_pg_result *this )
 }
 
 static void
-pgresult_gc_free( t_pg_result *this )
+pgresult_gc_free( void *_this )
 {
+	t_pg_result *this = (t_pg_result *)_this;
 	pgresult_clear( this );
 	xfree(this);
 }
 
 static size_t
-pgresult_memsize( t_pg_result *this )
+pgresult_memsize( const void *_this )
 {
+	const t_pg_result *this = (const t_pg_result *)_this;
 	/* Ideally the memory 'this' is pointing to should be taken into account as well.
 	 * However we don't want to store two memory sizes in t_pg_result just for reporting by ObjectSpace.memsize_of.
 	 */
@@ -155,16 +175,15 @@ pgresult_memsize( t_pg_result *this )
 }
 
 static const rb_data_type_t pgresult_type = {
-	"pg",
+	"PG::Result",
 	{
-		(void (*)(void*))pgresult_gc_mark,
-		(void (*)(void*))pgresult_gc_free,
-		(size_t (*)(const void *))pgresult_memsize,
+		pgresult_gc_mark,
+		pgresult_gc_free,
+		pgresult_memsize,
+		pg_compact_callback(pgresult_gc_compact),
 	},
 	0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
-	RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 /* Needed by sequel_pg gem, do not delete */
@@ -189,9 +208,11 @@ pg_new_result2(PGresult *result, VALUE rb_pgconn)
 
 	this = (t_pg_result *)xmalloc(sizeof(*this) +  sizeof(*this->fnames) * nfields);
 	this->pgresult = result;
+	/* Initialize connection and typemap prior to any object allocations,
+	 * to make sure valid objects are marked. */
 	this->connection = rb_pgconn;
 	this->typemap = pg_typemap_all_strings;
-	this->p_typemap = DATA_PTR( this->typemap );
+	this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 	this->nfields = -1;
 	this->tuple_hash = Qnil;
 	this->field_map = Qnil;
@@ -202,11 +223,12 @@ pg_new_result2(PGresult *result, VALUE rb_pgconn)
 		t_pg_connection *p_conn = pg_get_connection(rb_pgconn);
 		VALUE typemap = p_conn->type_map_for_results;
 		/* Type check is done when assigned to PG::Connection. */
-		t_typemap *p_typemap = DATA_PTR(typemap);
+		t_typemap *p_typemap = RTYPEDDATA_DATA(typemap);
 
 		this->enc_idx = p_conn->enc_idx;
-		this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
-		this->p_typemap = DATA_PTR( this->typemap );
+		typemap = p_typemap->funcs.fit_to_result( typemap, self );
+		RB_OBJ_WRITE(self, &this->typemap, typemap);
+		this->p_typemap = RTYPEDDATA_DATA( this->typemap );
 		this->flags = p_conn->flags;
 	} else {
 		this->enc_idx = rb_locale_encindex();
@@ -270,7 +292,11 @@ pg_new_result_autoclear(PGresult *result, VALUE rb_pgconn)
  * call-seq:
  *    res.check -> nil
  *
- * Raises appropriate exception if PG::Result is in a bad state.
+ * Raises appropriate exception if PG::Result is in a bad state, which is:
+ * * +PGRES_BAD_RESPONSE+
+ * * +PGRES_FATAL_ERROR+
+ * * +PGRES_NONFATAL_ERROR+
+ * * +PGRES_PIPELINE_ABORTED+
  */
 VALUE
 pg_result_check( VALUE self )
@@ -295,10 +321,16 @@ pg_result_check( VALUE self )
 		case PGRES_SINGLE_TUPLE:
 		case PGRES_EMPTY_QUERY:
 		case PGRES_COMMAND_OK:
+#ifdef HAVE_PQENTERPIPELINEMODE
+		case PGRES_PIPELINE_SYNC:
+#endif
 			return self;
 		case PGRES_BAD_RESPONSE:
 		case PGRES_FATAL_ERROR:
 		case PGRES_NONFATAL_ERROR:
+#ifdef HAVE_PQENTERPIPELINEMODE
+		case PGRES_PIPELINE_ABORTED:
+#endif
 			error = rb_str_new2( PQresultErrorMessage(this->pgresult) );
 			break;
 		default:
@@ -345,17 +377,37 @@ VALUE
 pg_result_clear(VALUE self)
 {
 	t_pg_result *this = pgresult_get_this(self);
+	rb_check_frozen(self);
 	pgresult_clear( this );
 	return Qnil;
 }
 
+/*
+ * call-seq:
+ *    res.freeze
+ *
+ * Freeze the PG::Result object and unlink the result from the related PG::Connection.
+ *
+ * A frozen PG::Result object doesn't allow any streaming and it can't be cleared.
+ * It also denies setting a type_map or field_name_type.
+ *
+ */
+static VALUE
+pg_result_freeze(VALUE self)
+{
+	t_pg_result *this = pgresult_get_this(self);
+
+	RB_OBJ_WRITE(self, &this->connection, Qnil);
+	return rb_call_super(0, NULL);
+}
+
 /*
  * call-seq:
  *    res.cleared?      -> boolean
  *
- * Returns +true+ if the backend result memory has been free'd.
+ * Returns +true+ if the backend result memory has been freed.
  */
-VALUE
+static VALUE
 pgresult_cleared_p( VALUE self )
 {
 	t_pg_result *this = pgresult_get_this(self);
@@ -367,12 +419,12 @@ pgresult_cleared_p( VALUE self )
  *    res.autoclear?      -> boolean
  *
  * Returns +true+ if the underlying C struct will be cleared at the end of a callback.
- * This applies only to Result objects received by the block to PG::Cinnection#set_notice_receiver .
+ * This applies only to Result objects received by the block to PG::Connection#set_notice_receiver .
  *
  * All other Result objects are automatically cleared by the GC when the object is no longer in use or manually by PG::Result#clear .
  *
  */
-VALUE
+static VALUE
 pgresult_autoclear_p( VALUE self )
 {
 	t_pg_result *this = pgresult_get_this(self);
@@ -448,7 +500,8 @@ static void pgresult_init_fnames(VALUE self)
 
 		for( i=0; i<nfields; i++ ){
 			char *cfname = PQfname(this->pgresult, i);
-			this->fnames[i] = pg_cstr_to_sym(cfname, this->flags, this->enc_idx);
+			VALUE fname = pg_cstr_to_sym(cfname, this->flags, this->enc_idx);
+			RB_OBJ_WRITE(self, &this->fnames[i], fname);
 			this->nfields = i + 1;
 		}
 		this->nfields = nfields;
@@ -495,6 +548,11 @@ static void pgresult_init_fnames(VALUE self)
  * * +PGRES_NONFATAL_ERROR+
  * * +PGRES_FATAL_ERROR+
  * * +PGRES_COPY_BOTH+
+ * * +PGRES_SINGLE_TUPLE+
+ * * +PGRES_PIPELINE_SYNC+
+ * * +PGRES_PIPELINE_ABORTED+
+ *
+ * Use <tt>res.res_status</tt> to retrieve the string representation.
  */
 static VALUE
 pgresult_result_status(VALUE self)
@@ -504,16 +562,38 @@ pgresult_result_status(VALUE self)
 
 /*
  * call-seq:
- *    res.res_status( status ) -> String
+ *    PG::Result.res_status( status ) -> String
  *
- * Returns the string representation of status +status+.
+ * Returns the string representation of +status+.
  *
 */
 static VALUE
-pgresult_res_status(VALUE self, VALUE status)
+pgresult_s_res_status(VALUE self, VALUE status)
+{
+	return rb_utf8_str_new_cstr(PQresStatus(NUM2INT(status)));
+}
+
+/*
+ * call-seq:
+ *    res.res_status -> String
+ *    res.res_status( status ) -> String
+ *
+ * Returns the string representation of the status of the result or of the provided +status+.
+ *
+ */
+static VALUE
+pgresult_res_status(int argc, VALUE *argv, VALUE self)
 {
 	t_pg_result *this = pgresult_get_this_safe(self);
-	VALUE ret = rb_str_new2(PQresStatus(NUM2INT(status)));
+	VALUE ret;
+
+	if( argc == 0 ){
+		ret = rb_str_new2(PQresStatus(PQresultStatus(this->pgresult)));
+	}else if( argc == 1 ){
+		ret = rb_str_new2(PQresStatus(NUM2INT(argv[0])));
+	}else{
+		rb_raise(rb_eArgError, "only 0 or 1 arguments expected");
+	}
 	PG_ENCODING_SET_NOCHECK(ret, this->enc_idx);
 	return ret;
 }
@@ -653,6 +733,21 @@ pgresult_nfields(VALUE self)
 	return INT2NUM(PQnfields(pgresult_get(self)));
 }
 
+/*
+ * call-seq:
+ *    res.binary_tuples() -> Integer
+ *
+ * Returns 1 if the PGresult contains binary data and 0 if it contains text data.
+ *
+ * This function is deprecated (except for its use in connection with COPY), because it is possible for a single PGresult to contain text data in some columns and binary data in others.
+ * Result#fformat is preferred. binary_tuples returns 1 only if all columns of the result are binary (format 1).
+ */
+static VALUE
+pgresult_binary_tuples(VALUE self)
+{
+	return INT2NUM(PQbinaryTuples(pgresult_get(self)));
+}
+
 /*
  * call-seq:
  *    res.fname( index ) -> String or Symbol
@@ -1003,7 +1098,7 @@ pgresult_cmd_tuples(VALUE self)
 {
 	long n;
 	n = strtol(PQcmdTuples(pgresult_get(self)),NULL, 10);
-	return INT2NUM(n);
+	return LONG2NUM(n);
 }
 
 /*
@@ -1055,7 +1150,7 @@ pgresult_aref(VALUE self, VALUE index)
 	}
 	/* Store a copy of the filled hash for use at the next row. */
 	if( num_tuples > 10 )
-		this->tuple_hash = rb_hash_dup(tuple);
+		RB_OBJ_WRITE(self, &this->tuple_hash, rb_hash_dup(tuple));
 
 	return tuple;
 }
@@ -1237,7 +1332,7 @@ static void ensure_init_for_tuple(VALUE self)
 			rb_hash_aset(field_map, this->fnames[i], INT2FIX(i));
 		}
 		rb_obj_freeze(field_map);
-		this->field_map = field_map;
+		RB_OBJ_WRITE(self, &this->field_map, field_map);
 	}
 }
 
@@ -1325,14 +1420,13 @@ pgresult_type_map_set(VALUE self, VALUE typemap)
 	t_pg_result *this = pgresult_get_this(self);
 	t_typemap *p_typemap;
 
-	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 ) );
-	}
-	Data_Get_Struct(typemap, t_typemap, p_typemap);
+	rb_check_frozen(self);
+	/* Check type of method param */
+	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, p_typemap);
 
-	this->typemap = p_typemap->funcs.fit_to_result( typemap, self );
-	this->p_typemap = DATA_PTR( this->typemap );
+	typemap = p_typemap->funcs.fit_to_result( typemap, self );
+	RB_OBJ_WRITE(self, &this->typemap, typemap);
+	this->p_typemap = RTYPEDDATA_DATA( typemap );
 
 	return typemap;
 }
@@ -1353,22 +1447,21 @@ pgresult_type_map_get(VALUE self)
 }
 
 
-static void
-yield_hash(VALUE self, int ntuples, int nfields)
+static int
+yield_hash(VALUE self, int ntuples, int nfields, void *data)
 {
 	int tuple_num;
-	t_pg_result *this = pgresult_get_this(self);
 	UNUSED(nfields);
 
 	for(tuple_num = 0; tuple_num < ntuples; tuple_num++) {
 		rb_yield(pgresult_aref(self, INT2NUM(tuple_num)));
 	}
 
-	pgresult_clear( this );
+	return 1; /* clear the result */
 }
 
-static void
-yield_array(VALUE self, int ntuples, int nfields)
+static int
+yield_array(VALUE self, int ntuples, int nfields, void *data)
 {
 	int row;
 	t_pg_result *this = pgresult_get_this(self);
@@ -1384,11 +1477,11 @@ yield_array(VALUE self, int ntuples, int nfields)
 		rb_yield( rb_ary_new4( nfields, row_values ));
 	}
 
-	pgresult_clear( this );
+	return 1; /* clear the result */
 }
 
-static void
-yield_tuple(VALUE self, int ntuples, int nfields)
+static int
+yield_tuple(VALUE self, int ntuples, int nfields, void *data)
 {
 	int tuple_num;
 	t_pg_result *this = pgresult_get_this(self);
@@ -1405,16 +1498,19 @@ yield_tuple(VALUE self, int ntuples, int nfields)
 		VALUE tuple = pgresult_tuple(copy, INT2FIX(tuple_num));
 		rb_yield( tuple );
 	}
+	return 0; /* don't clear the result */
 }
 
-static VALUE
-pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
+/* Non-static, and data pointer for use by sequel_pg */
+VALUE
+pgresult_stream_any(VALUE self, int (*yielder)(VALUE, int, int, void*), void* data)
 {
 	t_pg_result *this;
-	int nfields;
+	int nfields, nfields2;
 	PGconn *pgconn;
 	PGresult *pgresult;
 
+	rb_check_frozen(self);
 	RETURN_ENUMERATOR(self, 0, NULL);
 
 	this = pgresult_get_this_safe(self);
@@ -1427,6 +1523,7 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
 
 		switch( PQresultStatus(pgresult) ){
 			case PGRES_TUPLES_OK:
+			case PGRES_COMMAND_OK:
 				if( ntuples == 0 )
 					return self;
 				rb_raise( rb_eInvalidResultStatus, "PG::Result is not in single row mode");
@@ -1436,14 +1533,24 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
 				pg_result_check( self );
 		}
 
-		yielder( self, ntuples, nfields );
+		nfields2 = PQnfields(pgresult);
+		if( nfields != nfields2 ){
+			pgresult_clear( this );
+			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields changed in single row mode from %d to %d - this is a sign for intersection with another query", nfields, nfields2);
+		}
+
+		if( yielder( self, ntuples, nfields, data ) ){
+			pgresult_clear( this );
+		}
+
+		if( gvl_PQisBusy(pgconn) ){
+			/* wait for input (without blocking) before reading each result */
+			pgconn_block( 0, NULL, this->connection );
+		}
 
 		pgresult = gvl_PQgetResult(pgconn);
 		if( pgresult == NULL )
-			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another result retrieval");
-
-		if( nfields != PQnfields(pgresult) )
-			rb_raise( rb_eInvalidChangeOfResultFields, "number of fields must not change in single row mode");
+			rb_raise( rb_eNoResultError, "no result received - possibly an intersection with another query");
 
 		this->pgresult = pgresult;
 	}
@@ -1487,7 +1594,7 @@ pgresult_stream_any(VALUE self, void (*yielder)(VALUE, int, int))
 static VALUE
 pgresult_stream_each(VALUE self)
 {
-	return pgresult_stream_any(self, yield_hash);
+	return pgresult_stream_any(self, yield_hash, NULL);
 }
 
 /*
@@ -1503,7 +1610,7 @@ pgresult_stream_each(VALUE self)
 static VALUE
 pgresult_stream_each_row(VALUE self)
 {
-	return pgresult_stream_any(self, yield_array);
+	return pgresult_stream_any(self, yield_array, NULL);
 }
 
 /*
@@ -1520,7 +1627,7 @@ pgresult_stream_each_tuple(VALUE self)
 	/* allocate VALUEs that are shared between all streamed tuples */
 	ensure_init_for_tuple(self);
 
-	return pgresult_stream_any(self, yield_tuple);
+	return pgresult_stream_any(self, yield_tuple, NULL);
 }
 
 /*
@@ -1531,7 +1638,7 @@ pgresult_stream_each_tuple(VALUE self)
  * It can be set to one of:
  * * +:string+ to use String based field names
  * * +:symbol+ to use Symbol based field names
- * * +:static_symbol+ to use pinned Symbol (can not be garbage collected) - Don't use this, it will probably removed in future.
+ * * +:static_symbol+ to use pinned Symbol (can not be garbage collected) - Don't use this, it will probably be removed in future.
  *
  * The default is retrieved from PG::Connection#field_name_type , which defaults to +:string+ .
  *
@@ -1548,6 +1655,8 @@ static VALUE
 pgresult_field_name_type_set(VALUE self, VALUE sym)
 {
 	t_pg_result *this = pgresult_get_this(self);
+
+	rb_check_frozen(self);
 	if( this->nfields != -1 ) rb_raise(rb_eArgError, "field names are already materialized");
 
 	this->flags &= ~PG_RESULT_FIELD_NAMES_MASK;
@@ -1581,19 +1690,21 @@ pgresult_field_name_type_get(VALUE self)
 }
 
 void
-init_pg_result()
+init_pg_result(void)
 {
 	sym_string = ID2SYM(rb_intern("string"));
 	sym_symbol = ID2SYM(rb_intern("symbol"));
 	sym_static_symbol = ID2SYM(rb_intern("static_symbol"));
 
-	rb_cPGresult = rb_define_class_under( rb_mPG, "Result", rb_cData );
+	rb_cPGresult = rb_define_class_under( rb_mPG, "Result", rb_cObject );
+	rb_undef_alloc_func(rb_cPGresult);
 	rb_include_module(rb_cPGresult, rb_mEnumerable);
 	rb_include_module(rb_cPGresult, rb_mPGconstants);
 
 	/******     PG::Result INSTANCE METHODS: libpq     ******/
 	rb_define_method(rb_cPGresult, "result_status", pgresult_result_status, 0);
-	rb_define_method(rb_cPGresult, "res_status", pgresult_res_status, 1);
+	rb_define_method(rb_cPGresult, "res_status", pgresult_res_status, -1);
+	rb_define_singleton_method(rb_cPGresult, "res_status", pgresult_s_res_status, 1);
 	rb_define_method(rb_cPGresult, "error_message", pgresult_error_message, 0);
 	rb_define_alias( rb_cPGresult, "result_error_message", "error_message");
 #ifdef HAVE_PQRESULTVERBOSEERRORMESSAGE
@@ -1603,12 +1714,14 @@ init_pg_result()
 	rb_define_method(rb_cPGresult, "error_field", pgresult_error_field, 1);
 	rb_define_alias( rb_cPGresult, "result_error_field", "error_field" );
 	rb_define_method(rb_cPGresult, "clear", pg_result_clear, 0);
+	rb_define_method(rb_cPGresult, "freeze", pg_result_freeze, 0 );
 	rb_define_method(rb_cPGresult, "check", pg_result_check, 0);
 	rb_define_alias (rb_cPGresult, "check_result", "check");
 	rb_define_method(rb_cPGresult, "ntuples", pgresult_ntuples, 0);
 	rb_define_alias(rb_cPGresult, "num_tuples", "ntuples");
 	rb_define_method(rb_cPGresult, "nfields", pgresult_nfields, 0);
 	rb_define_alias(rb_cPGresult, "num_fields", "nfields");
+	rb_define_method(rb_cPGresult, "binary_tuples", pgresult_binary_tuples, 0);
 	rb_define_method(rb_cPGresult, "fname", pgresult_fname, 1);
 	rb_define_method(rb_cPGresult, "fnumber", pgresult_fnumber, 1);
 	rb_define_method(rb_cPGresult, "ftable", pgresult_ftable, 1);

data/ext/pg_text_decoder.c

@@ -43,7 +43,6 @@
 #include <string.h>
 
 VALUE rb_mPG_TextDecoder;
-static ID s_id_decode;
 static ID s_id_Rational;
 static ID s_id_new;
 static ID s_id_utc;
@@ -171,6 +170,19 @@ pg_text_dec_numeric(t_pg_coder *conv, const char *val, int len, int tuple, int f
 	return rb_funcall(rb_cObject, s_id_BigDecimal, 1, rb_str_new(val, len));
 }
 
+/* called per autoload when TextDecoder::Numeric is used */
+static VALUE
+init_pg_text_decoder_numeric(VALUE rb_mPG_TextDecoder)
+{
+	rb_require("bigdecimal");
+	s_id_BigDecimal = rb_intern("BigDecimal");
+
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Numeric", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Numeric", pg_text_dec_numeric, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
+
+	return Qnil;
+}
+
 /*
  * Document-class: PG::TextDecoder::Float < PG::SimpleDecoder
  *
@@ -854,7 +866,7 @@ pg_text_dec_inet(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
 
 		ip_int_native = read_nbo32(dst);
 
-		/* Work around broken IPAddr behavior of convering portion
+		/* Work around broken IPAddr behavior of converting portion
 		   of address after netmask to 0 */
 		switch (mask) {
 			case 0:
@@ -922,8 +934,9 @@ pg_text_dec_inet(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
 	return ip;
 }
 
-void
-init_pg_text_decoder()
+/* called per autoload when TextDecoder::Inet is used */
+static VALUE
+init_pg_text_decoder_inet(VALUE rb_mPG_TextDecoder)
 {
 	rb_require("ipaddr");
 	s_IPAddr = rb_funcall(rb_cObject, rb_intern("const_get"), 1, rb_str_new2("IPAddr"));
@@ -942,14 +955,21 @@ init_pg_text_decoder()
 	s_vmasks6 = rb_eval_string("a = [0]*129; a[0] = 0; a[128] = 0xffffffffffffffffffffffffffffffff; 127.downto(1){|i| a[i] = a[i+1] - (1 << (127 - i))}; a.freeze");
 	rb_global_variable(&s_vmasks6);
 
-	s_id_decode = rb_intern("decode");
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Inet", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Inet", pg_text_dec_inet, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder);
+
+	return Qnil;
+}
+
+
+void
+init_pg_text_decoder(void)
+{
 	s_id_Rational = rb_intern("Rational");
 	s_id_new = rb_intern("new");
 	s_id_utc = rb_intern("utc");
 	s_id_getlocal = rb_intern("getlocal");
 
-	rb_require("bigdecimal");
-	s_id_BigDecimal = rb_intern("BigDecimal");
 	s_nan = rb_eval_string("0.0/0.0");
 	rb_global_variable(&s_nan);
 	s_pos_inf = rb_eval_string("1.0/0.0");
@@ -959,6 +979,8 @@ init_pg_text_decoder()
 
 	/* This module encapsulates all decoder classes with text input format */
 	rb_mPG_TextDecoder = rb_define_module_under( rb_mPG, "TextDecoder" );
+	rb_define_private_method(rb_singleton_class(rb_mPG_TextDecoder), "init_inet", init_pg_text_decoder_inet, 0);
+	rb_define_private_method(rb_singleton_class(rb_mPG_TextDecoder), "init_numeric", init_pg_text_decoder_numeric, 0);
 
 	/* Make RDoc aware of the decoder classes... */
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Boolean", rb_cPG_SimpleDecoder ); */
@@ -967,8 +989,6 @@ init_pg_text_decoder()
 	pg_define_coder( "Integer", pg_text_dec_integer, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Float", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Float", pg_text_dec_float, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
-	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Numeric", rb_cPG_SimpleDecoder ); */
-	pg_define_coder( "Numeric", pg_text_dec_numeric, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "String", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Bytea", rb_cPG_SimpleDecoder ); */
@@ -977,8 +997,6 @@ init_pg_text_decoder()
 	pg_define_coder( "Identifier", pg_text_dec_identifier, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Timestamp", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Timestamp", pg_text_dec_timestamp, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder);
-	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Inet", rb_cPG_SimpleDecoder ); */
-	pg_define_coder( "Inet", pg_text_dec_inet, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder);
 
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Array", rb_cPG_CompositeDecoder ); */
 	pg_define_coder( "Array", pg_text_dec_array, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );