pg 0.17.1 → 0.18.4

data/ext/extconf.rb

@@ -15,36 +15,35 @@ if pgdir = with_config( 'pg' )
 	ENV['PATH'] = "#{pgdir}/bin" + File::PATH_SEPARATOR + ENV['PATH']
 end
 
-if ENV['CROSS_COMPILING']
-	$LDFLAGS << " -L#{CONFIG['libdir']}"
-
-	# Link against all required libraries for static build, if they are available
-	have_library( 'crypt32', 'CertOpenStore' ) && append_library( $libs, 'crypt32' )
-	have_library( 'gdi32', 'CreateDC' ) && append_library( $libs, 'gdi32' )
-	have_library( 'secur32' ) && append_library( $libs, 'secur32' )
-	have_library( 'ws2_32', 'WSASocket') && append_library( $libs, 'ws2_32' )
-	have_library( 'crypto', 'BIO_new' ) && append_library( $libs, 'crypto' )
-	have_library( 'ssl', 'SSL_new' ) && append_library( $libs, 'ssl' )
-end
+if enable_config("windows-cross")
+	# Avoid dependency to external libgcc.dll on x86-mingw32
+	$LDFLAGS << " -static-libgcc"
+	# Don't use pg_config for cross build, but --with-pg-* path options
+	dir_config 'pg'
 
-if pgconfig = ( with_config('pg-config') || with_config('pg_config') || find_executable('pg_config') )
-	$stderr.puts "Using config values from %s" % [ pgconfig ]
-	incdir = `"#{pgconfig}" --includedir`.chomp
-	libdir = `"#{pgconfig}" --libdir`.chomp
-	dir_config 'pg', incdir, libdir
-
-	# Try to use runtime path linker option, even if RbConfig doesn't know about it.
-	# The rpath option is usually set implicit by dir_config(), but so far not
-	# on MacOS-X.
-	if RbConfig::CONFIG["RPATHFLAG"].to_s.empty? && try_link('int main() {return 0;}', " -Wl,-rpath,#{libdir}")
-		$LDFLAGS << " -Wl,-rpath,#{libdir}"
-	end
 else
-	$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
-		" --with-pg-config=/path/to/pg_config"
-	dir_config 'pg'
+	# Native build
+
+	if pgconfig = ( with_config('pg-config') || with_config('pg_config') || find_executable('pg_config') )
+		$stderr.puts "Using config values from %s" % [ pgconfig ]
+		incdir = `"#{pgconfig}" --includedir`.chomp
+		libdir = `"#{pgconfig}" --libdir`.chomp
+		dir_config 'pg', incdir, libdir
+
+		# Try to use runtime path linker option, even if RbConfig doesn't know about it.
+		# The rpath option is usually set implicit by dir_config(), but so far not
+		# on MacOS-X.
+		if RbConfig::CONFIG["RPATHFLAG"].to_s.empty? && try_link('int main() {return 0;}', " -Wl,-rpath,#{libdir}")
+			$LDFLAGS << " -Wl,-rpath,#{libdir}"
+		end
+	else
+		$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
+			" --with-pg-config=/path/to/pg_config"
+		dir_config 'pg'
+	end
 end
 
+
 find_header( 'libpq-fe.h' ) or abort "Can't find the 'libpq-fe.h header"
 find_header( 'libpq/libpq-fs.h' ) or abort "Can't find the 'libpq/libpq-fs.h header"
 find_header( 'pg_config_manual.h' ) or abort "Can't find the 'pg_config_manual.h' header"
@@ -73,6 +72,7 @@ have_func 'PQsetClientEncoding'
 have_func 'PQlibVersion'
 have_func 'PQping'
 have_func 'PQsetSingleRowMode'
+have_func 'PQconninfo'
 
 have_func 'rb_encdb_alias'
 have_func 'rb_enc_alias'
@@ -80,6 +80,8 @@ have_func 'rb_thread_call_without_gvl'
 have_func 'rb_thread_call_with_gvl'
 have_func 'rb_thread_fd_select'
 have_func 'rb_w32_wrap_io_handle'
+have_func 'rb_str_modify_expand'
+have_func 'rb_hash_dup'
 
 have_const 'PGRES_COPY_BOTH', 'libpq-fe.h'
 have_const 'PGRES_SINGLE_TUPLE', 'libpq-fe.h'
@@ -90,8 +92,13 @@ $defs.push( "-DHAVE_ST_NOTIFY_EXTRA" ) if
 
 # unistd.h confilicts with ruby/win32.h when cross compiling for win32 and ruby 1.9.1
 have_header 'unistd.h'
+have_header 'inttypes.h'
 have_header 'ruby/st.h' or have_header 'st.h' or abort "pg currently requires the ruby/st.h header"
 
+checking_for "C99 variable length arrays" do
+	$defs.push( "-DHAVE_VARIABLE_LENGTH_ARRAYS" ) if try_compile('void test_vla(int l){ int vla[l]; }')
+end
+
 create_header()
 create_makefile( "pg_ext" )
 

data/ext/pg.c

@@ -1,6 +1,6 @@
 /*
  * pg.c - Toplevel extension
- * $Id: pg.c,v 74aa9514a381 2013/05/18 17:29:19 lars $
+ * $Id: pg.c,v b60c89ee93c8 2015/02/11 20:59:36 lars $
  *
  * Author/s:
  *
@@ -15,7 +15,7 @@
  * See Contributors.rdoc for the many additional fine people that have contributed
  * to this library over the years.
  *
- * Copyright (c) 1997-2012 by the authors.
+ * Copyright (c) 1997-2015 by the authors.
  *
  * You may redistribute this software under the same terms as Ruby itself; see
  * http://www.ruby-lang.org/en/LICENSE.txt or the LICENSE file in the source
@@ -123,24 +123,6 @@ const char * const (pg_enc_pg2ruby_mapping[][2]) = {
  * A cache of mapping from PostgreSQL's encoding indices to Ruby's rb_encoding*s.
  */
 static struct st_table *enc_pg2ruby;
-static ID s_id_index;
-
-
-/*
- * Get the index of encoding +val+.
- * :FIXME: Look into replacing this with rb_enc_get_index() since 1.9.1 isn't really
- * used anymore.
- */
-int
-pg_enc_get_index(VALUE val)
-{
-	int i = ENCODING_GET_INLINED(val);
-	if (i == ENCODING_INLINE_MAX) {
-		VALUE iv = rb_ivar_get(val, s_id_index);
-		i = NUM2INT(iv);
-	}
-	return i;
-}
 
 
 /*
@@ -249,6 +231,68 @@ pg_get_rb_encoding_as_pg_encoding( rb_encoding *enc )
 #endif /* M17N_SUPPORTED */
 
 
+/*
+ * Ensures that the given string has enough capacity to take expand_len
+ * more data bytes. The new data part of the String is not initialized.
+ *
+ * current_out must be a pointer within the data part of the String object.
+ * This pointer is returned and possibly adjusted, because the location of the data
+ * part of the String can change through this function.
+ *
+ * PG_RB_STR_ENSURE_CAPA can be used to do fast inline checks of the remaining capacity.
+ * end_capa it is then set to the first byte after the currently reserved memory,
+ * if not NULL.
+ *
+ * Before the String can be used with other string functions or returned to Ruby space,
+ * the string length has to be set with rb_str_set_len().
+ *
+ * Usage example:
+ *
+ *   VALUE string;
+ *   char *current_out, *end_capa;
+ *   PG_RB_STR_NEW( string, current_out, end_capa );
+ *   while( data_is_going_to_be_processed ){
+ *     PG_RB_STR_ENSURE_CAPA( string, 2, current_out, end_capa );
+ *     *current_out++ = databyte1;
+ *     *current_out++ = databyte2;
+ *   }
+ *   rb_str_set_len( string, current_out - RSTRING_PTR(string) );
+ *
+ */
+#ifdef HAVE_RB_STR_MODIFY_EXPAND
+	/* Use somewhat faster version with access to string capacity on MRI */
+	char *
+	pg_rb_str_ensure_capa( VALUE str, long expand_len, char *curr_ptr, char **end_ptr )
+	{
+		long curr_len = curr_ptr - RSTRING_PTR(str);
+		long curr_capa = rb_str_capacity( str );
+		if( curr_capa < curr_len + expand_len ){
+			rb_str_set_len( str, curr_len );
+			rb_str_modify_expand( str, (curr_len + expand_len) * 2 - curr_capa );
+			curr_ptr = RSTRING_PTR(str) + curr_len;
+		}
+		if( end_ptr )
+			*end_ptr = RSTRING_PTR(str) + rb_str_capacity( str );
+		return curr_ptr;
+	}
+#else
+	/* Use the more portable version */
+	char *
+	pg_rb_str_ensure_capa( VALUE str, long expand_len, char *curr_ptr, char **end_ptr )
+	{
+		long curr_len = curr_ptr - RSTRING_PTR(str);
+		long curr_capa = RSTRING_LEN( str );
+		if( curr_capa < curr_len + expand_len ){
+			rb_str_resize( str, (curr_len + expand_len) * 2 - curr_capa );
+			curr_ptr = RSTRING_PTR(str) + curr_len;
+		}
+		if( end_ptr )
+			*end_ptr = RSTRING_PTR(str) + RSTRING_LEN(str);
+		return curr_ptr;
+	}
+#endif
+
+
 /**************************************************************************
  * Module Methods
  **************************************************************************/
@@ -289,6 +333,67 @@ pg_s_threadsafe_p(VALUE self)
 	return PQisthreadsafe() ? Qtrue : Qfalse;
 }
 
+static int
+pg_to_bool_int(VALUE value)
+{
+	switch( TYPE(value) ){
+		case T_FALSE:
+			return 0;
+		case T_TRUE:
+			return 1;
+		default:
+			return NUM2INT(value);
+	}
+}
+
+/*
+ * call-seq:
+ *    PG.init_openssl(do_ssl, do_crypto)  -> nil
+ *
+ * Allows applications to select which security libraries to initialize.
+ *
+ * If your application initializes libssl and/or libcrypto libraries and libpq is
+ * built with SSL support, you should call PG.init_openssl() to tell libpq that the
+ * libssl and/or libcrypto libraries have been initialized by your application,
+ * so that libpq will not also initialize those libraries. See
+ * http://h71000.www7.hp.com/doc/83final/BA554_90007/ch04.html for details on the SSL API.
+ *
+ * When do_ssl is +true+, libpq will initialize the OpenSSL library before first
+ * opening a database connection. When do_crypto is +true+, the libcrypto library
+ * will be initialized. By default (if PG.init_openssl() is not called), both libraries
+ * are initialized. When SSL support is not compiled in, this function is present but does nothing.
+ *
+ * If your application uses and initializes either OpenSSL or its underlying libcrypto library,
+ * you must call this function with +false+ for the appropriate parameter(s) before first opening
+ * a database connection. Also be sure that you have done that initialization before opening a
+ * database connection.
+ *
+ */
+static VALUE
+pg_s_init_openssl(VALUE self, VALUE do_ssl, VALUE do_crypto)
+{
+	UNUSED( self );
+	PQinitOpenSSL(pg_to_bool_int(do_ssl), pg_to_bool_int(do_crypto));
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *    PG.init_ssl(do_ssl)  -> nil
+ *
+ * Allows applications to select which security libraries to initialize.
+ *
+ * This function is equivalent to <tt>PG.init_openssl(do_ssl, do_ssl)</tt> . It is sufficient for
+ * applications that initialize both or neither of OpenSSL and libcrypto.
+ */
+static VALUE
+pg_s_init_ssl(VALUE self, VALUE do_ssl)
+{
+	UNUSED( self );
+	PQinitSSL(pg_to_bool_int(do_ssl));
+	return Qnil;
+}
 
 
 /**************************************************************************
@@ -311,6 +416,10 @@ Init_pg_ext()
 	SINGLETON_ALIAS( rb_mPG, "is_threadsafe?", "isthreadsafe" );
 	SINGLETON_ALIAS( rb_mPG, "threadsafe?", "isthreadsafe" );
 
+  rb_define_singleton_method( rb_mPG, "init_openssl", pg_s_init_openssl, 2 );
+  rb_define_singleton_method( rb_mPG, "init_ssl", pg_s_init_ssl, 1 );
+
+
 	/******     PG::Connection CLASS CONSTANTS: Connection Status     ******/
 
 	/* Connection succeeded */
@@ -534,12 +643,24 @@ Init_pg_ext()
 
 #ifdef M17N_SUPPORTED
 	enc_pg2ruby = st_init_numtable();
-	s_id_index = rb_intern("@encoding");
 #endif
 
 	/* Initialize the main extension classes */
 	init_pg_connection();
 	init_pg_result();
 	init_pg_errors();
+	init_pg_type_map();
+	init_pg_type_map_all_strings();
+	init_pg_type_map_by_class();
+	init_pg_type_map_by_column();
+	init_pg_type_map_by_mri_type();
+	init_pg_type_map_by_oid();
+	init_pg_type_map_in_ruby();
+	init_pg_coder();
+	init_pg_text_encoder();
+	init_pg_text_decoder();
+	init_pg_binary_encoder();
+	init_pg_binary_decoder();
+	init_pg_copycoder();
 }
 

data/ext/pg.h

@@ -24,7 +24,6 @@
 #if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
 #	include "ruby/encoding.h"
 #	define M17N_SUPPORTED
-#	define ASSOCIATE_INDEX( obj, index_holder ) rb_enc_associate_index((obj), pg_enc_get_index((index_holder)))
 #	ifdef HAVE_RB_ENCDB_ALIAS
 		extern int rb_encdb_alias(const char *, const char *);
 #		define ENC_ALIAS(name, orig) rb_encdb_alias((name), (orig))
@@ -35,8 +34,28 @@
 		extern int rb_enc_alias(const char *alias, const char *orig); /* declaration missing in Ruby 1.9.1 */
 #		define ENC_ALIAS(name, orig) rb_enc_alias((name), (orig))
 #	endif
+
+
+# if !defined(ENCODING_SET_INLINED)
+/* Rubinius doesn't define ENCODING_SET_INLINED, so we fall back to the more
+ * portable version.
+ */
+#  define PG_ENCODING_SET_NOCHECK(obj,i) \
+	do { \
+		rb_enc_set_index((obj), (i)); \
+	} while(0)
+# else
+#  define PG_ENCODING_SET_NOCHECK(obj,i) \
+	do { \
+		if ((i) < ENCODING_INLINE_MAX) \
+			ENCODING_SET_INLINED((obj), (i)); \
+		else \
+			rb_enc_set_index((obj), (i)); \
+	} while(0)
+# endif
+
 #else
-#	define ASSOCIATE_INDEX( obj, index_holder ) /* nothing */
+#	define PG_ENCODING_SET_NOCHECK(obj,i) /* nothing */
 #endif
 
 #if RUBY_VM != 1
@@ -66,6 +85,20 @@
 #	include "ruby/io.h"
 #endif
 
+#ifdef RUBINIUS
+	/* Workaround for wrong FIXNUM_MAX definition */
+	typedef intptr_t native_int;
+#endif
+
+#ifndef RETURN_SIZED_ENUMERATOR
+	#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) RETURN_ENUMERATOR((obj), (argc), (argv))
+#endif
+
+#ifndef HAVE_RB_HASH_DUP
+	/* Rubinius doesn't define rb_hash_dup() */
+	#define rb_hash_dup(tuple) rb_funcall((tuple), rb_intern("dup"), 0)
+#endif
+
 #ifndef timeradd
 #define timeradd(a, b, result) \
 	do { \
@@ -97,10 +130,126 @@
 
 #if defined(_WIN32)
 #	include <fcntl.h>
-__declspec(dllexport)
 typedef long suseconds_t;
 #endif
 
+#if defined(HAVE_VARIABLE_LENGTH_ARRAYS)
+	#define PG_VARIABLE_LENGTH_ARRAY(type, name, len, maxlen) type name[(len)];
+#else
+	#define PG_VARIABLE_LENGTH_ARRAY(type, name, len, maxlen) \
+		type name[(maxlen)] = {(len)>(maxlen) ? (rb_raise(rb_eArgError, "Number of " #name " (%d) exceeds allowed maximum of " #maxlen, (len) ), (type)1) : (type)0};
+
+	#define PG_MAX_COLUMNS 4000
+#endif
+
+/* The data behind each PG::Connection object */
+typedef struct {
+	PGconn *pgconn;
+
+	/* Cached IO object for the socket descriptor */
+	VALUE socket_io;
+	/* Proc object that receives notices as PG::Result objects */
+	VALUE notice_receiver;
+	/* Proc object that receives notices as String objects */
+	VALUE notice_processor;
+	/* Kind of PG::TypeMap object for casting query params */
+	VALUE type_map_for_queries;
+	/* Kind of PG::TypeMap object for casting result values */
+	VALUE type_map_for_results;
+	/* IO object internally used for the trace stream */
+	VALUE trace_stream;
+	/* Cached Encoding object */
+	VALUE external_encoding;
+	/* Kind of PG::Coder object for casting ruby values to COPY rows */
+	VALUE encoder_for_put_copy_data;
+	/* Kind of PG::Coder object for casting COPY rows to ruby values */
+	VALUE decoder_for_get_copy_data;
+
+} t_pg_connection;
+
+typedef struct pg_coder t_pg_coder;
+typedef struct pg_typemap t_typemap;
+
+/* The data behind each PG::Result object */
+typedef struct {
+	PGresult *pgresult;
+
+	/* The connection object used to build this result */
+	VALUE connection;
+
+	/* The TypeMap used to type cast result values */
+	VALUE typemap;
+
+	/* Pointer to the typemap object data. This is assumed to be
+	 * always valid.
+	 */
+	t_typemap *p_typemap;
+
+	/* 0 = PGresult is cleared by PG::Result#clear or by the GC
+	 * 1 = PGresult is cleared internally by libpq
+	 */
+	int autoclear;
+
+	/* Number of fields in fnames[] .
+	 * Set to -1 if fnames[] is not yet initialized.
+	 */
+	int nfields;
+
+	/* Prefilled tuple Hash with fnames[] as keys. */
+	VALUE tuple_hash;
+
+	/* List of field names as frozen String objects.
+	 * Only valid if nfields != -1
+	 */
+	VALUE fnames[0];
+} t_pg_result;
+
+
+typedef int (* t_pg_coder_enc_func)(t_pg_coder *, VALUE, char *, VALUE *);
+typedef VALUE (* t_pg_coder_dec_func)(t_pg_coder *, char *, int, int, int, int);
+typedef VALUE (* t_pg_fit_to_result)(VALUE, VALUE);
+typedef VALUE (* t_pg_fit_to_query)(VALUE, VALUE);
+typedef int (* t_pg_fit_to_copy_get)(VALUE);
+typedef VALUE (* t_pg_typecast_result)(t_typemap *, VALUE, int, int);
+typedef t_pg_coder *(* t_pg_typecast_query_param)(t_typemap *, VALUE, int);
+typedef VALUE (* t_pg_typecast_copy_get)( t_typemap *, VALUE, int, int, int );
+
+struct pg_coder {
+	t_pg_coder_enc_func enc_func;
+	t_pg_coder_dec_func dec_func;
+	VALUE coder_obj;
+	Oid oid;
+	int format;
+};
+
+typedef struct {
+	t_pg_coder comp;
+	t_pg_coder *elem;
+	int needs_quotation;
+	char delimiter;
+} t_pg_composite_coder;
+
+struct pg_typemap {
+	struct pg_typemap_funcs {
+		t_pg_fit_to_result fit_to_result;
+		t_pg_fit_to_query fit_to_query;
+		t_pg_fit_to_copy_get fit_to_copy_get;
+		t_pg_typecast_result typecast_result_value;
+		t_pg_typecast_query_param typecast_query_param;
+		t_pg_typecast_copy_get typecast_copy_get;
+	} funcs;
+	VALUE default_typemap;
+};
+
+typedef struct {
+	t_typemap typemap;
+	int nfields;
+	struct pg_tmbc_converter {
+		t_pg_coder *cconv;
+	} convs[0];
+} t_tmbc;
+
+
 #include "gvl_wrappers.h"
 
 /***************************************************************************
@@ -112,11 +261,33 @@ extern VALUE rb_ePGerror;
 extern VALUE rb_eServerError;
 extern VALUE rb_eUnableToSend;
 extern VALUE rb_eConnectionBad;
+extern VALUE rb_eInvalidResultStatus;
+extern VALUE rb_eNoResultError;
+extern VALUE rb_eInvalidChangeOfResultFields;
 extern VALUE rb_mPGconstants;
 extern VALUE rb_cPGconn;
 extern VALUE rb_cPGresult;
 extern VALUE rb_hErrors;
+extern VALUE rb_cTypeMap;
+extern VALUE rb_cTypeMapAllStrings;
+extern VALUE rb_mDefaultTypeMappable;
+extern VALUE rb_cPG_Coder;
+extern VALUE rb_cPG_SimpleEncoder;
+extern VALUE rb_cPG_SimpleDecoder;
+extern VALUE rb_cPG_CompositeEncoder;
+extern VALUE rb_cPG_CompositeDecoder;
+extern VALUE rb_cPG_CopyCoder;
+extern VALUE rb_cPG_CopyEncoder;
+extern VALUE rb_cPG_CopyDecoder;
+extern VALUE rb_mPG_TextEncoder;
+extern VALUE rb_mPG_TextDecoder;
+extern VALUE rb_mPG_BinaryEncoder;
+extern VALUE rb_mPG_BinaryDecoder;
+extern VALUE rb_mPG_BinaryFormatting;
+extern const struct pg_typemap_funcs pg_tmbc_funcs;
+extern const struct pg_typemap_funcs pg_typemap_funcs;
 
+extern VALUE pg_typemap_all_strings;
 
 /***************************************************************************
  * MACROS
@@ -134,19 +305,84 @@ void Init_pg_ext                                       _(( void ));
 void init_pg_connection                                _(( void ));
 void init_pg_result                                    _(( void ));
 void init_pg_errors                                    _(( void ));
-VALUE lookup_error_class                               _(( const char *sqlstate ));
+void init_pg_type_map                                  _(( void ));
+void init_pg_type_map_all_strings                      _(( void ));
+void init_pg_type_map_by_class                         _(( void ));
+void init_pg_type_map_by_column                        _(( void ));
+void init_pg_type_map_by_mri_type                      _(( void ));
+void init_pg_type_map_by_oid                           _(( void ));
+void init_pg_type_map_in_ruby                          _(( void ));
+void init_pg_coder                                     _(( void ));
+void init_pg_copycoder                                 _(( void ));
+void init_pg_text_encoder                              _(( void ));
+void init_pg_text_decoder                              _(( void ));
+void init_pg_binary_encoder                            _(( void ));
+void init_pg_binary_decoder                            _(( void ));
+VALUE lookup_error_class                               _(( const char * ));
+VALUE pg_bin_dec_bytea                                 _(( t_pg_coder*, char *, int, int, int, int ));
+VALUE pg_text_dec_string                               _(( t_pg_coder*, char *, int, int, int, int ));
+int pg_coder_enc_to_s                                  _(( t_pg_coder*, VALUE, char *, VALUE *));
+int pg_text_enc_identifier                             _(( t_pg_coder*, VALUE, char *, VALUE *));
+t_pg_coder_enc_func pg_coder_enc_func                  _(( t_pg_coder* ));
+t_pg_coder_dec_func pg_coder_dec_func                  _(( t_pg_coder*, int ));
+void pg_define_coder                                   _(( const char *, void *, VALUE, VALUE ));
+VALUE pg_obj_to_i                                      _(( VALUE ));
+VALUE pg_tmbc_allocate                                 _(( void ));
+void pg_coder_init_encoder                             _(( VALUE ));
+void pg_coder_init_decoder                             _(( VALUE ));
+char *pg_rb_str_ensure_capa                            _(( VALUE, long, char *, char ** ));
+
+#define PG_RB_STR_ENSURE_CAPA( str, expand_len, curr_ptr, end_ptr ) \
+	do { \
+		if( (curr_ptr) + (expand_len) >= (end_ptr) ) \
+			(curr_ptr) = pg_rb_str_ensure_capa( (str), (expand_len), (curr_ptr), &(end_ptr) ); \
+	} while(0);
+
+#define PG_RB_STR_NEW( str, curr_ptr, end_ptr ) ( \
+		(str) = rb_str_new( NULL, 0 ), \
+		(curr_ptr) = (end_ptr) = RSTRING_PTR(str) \
+	)
+
+#define PG_RB_TAINTED_STR_NEW( str, curr_ptr, end_ptr ) ( \
+		(str) = rb_tainted_str_new( NULL, 0 ), \
+		(curr_ptr) = (end_ptr) = RSTRING_PTR(str) \
+	)
 
-PGconn *pg_get_pgconn	                               _(( VALUE ));
+VALUE pg_typemap_fit_to_result                         _(( VALUE, VALUE ));
+VALUE pg_typemap_fit_to_query                          _(( VALUE, VALUE ));
+int pg_typemap_fit_to_copy_get                         _(( VALUE ));
+VALUE pg_typemap_result_value                          _(( t_typemap *, VALUE, int, int ));
+t_pg_coder *pg_typemap_typecast_query_param            _(( t_typemap *, VALUE, int ));
+VALUE pg_typemap_typecast_copy_get                     _(( t_typemap *, VALUE, int, int, int ));
+
+PGconn *pg_get_pgconn                                  _(( VALUE ));
+t_pg_connection *pg_get_connection                     _(( VALUE ));
 
 VALUE pg_new_result                                    _(( PGresult *, VALUE ));
+VALUE pg_new_result_autoclear                          _(( PGresult *, VALUE ));
+PGresult* pgresult_get                                 _(( VALUE ));
 VALUE pg_result_check                                  _(( VALUE ));
 VALUE pg_result_clear                                  _(( VALUE ));
 
+/*
+ * Fetch the data pointer for the result object
+ */
+static inline t_pg_result *
+pgresult_get_this( VALUE self )
+{
+	t_pg_result *this = DATA_PTR(self);
+
+	if( this == NULL )
+		rb_raise(rb_ePGerror, "result has been cleared");
+
+	return this;
+}
+
+
 #ifdef M17N_SUPPORTED
 rb_encoding * pg_get_pg_encoding_as_rb_encoding        _(( int ));
 rb_encoding * pg_get_pg_encname_as_rb_encoding         _(( const char * ));
 const char * pg_get_rb_encoding_as_pg_encoding         _(( rb_encoding * ));
-int pg_enc_get_index                                   _(( VALUE ));
 rb_encoding *pg_conn_enc_get                           _(( PGconn * ));
 #endif /* M17N_SUPPORTED */