kamk-pg 0.8.0 → 0.8.0.3

data/ext/compat.h

@@ -0,0 +1,180 @@
+
+#ifndef __compat_h
+#define __compat_h
+
+#include <stdlib.h>
+
+#include "libpq-fe.h"
+#include "libpq/libpq-fs.h"              /* large-object interface */
+
+#include "ruby.h"
+
+/* pg_config.h does not exist in older versions of
+ * PostgreSQL, so I can't effectively use PG_VERSION_NUM
+ * Instead, I create some #defines to help organization.
+ */
+#ifndef HAVE_PQCONNECTIONUSEDPASSWORD
+#define PG_BEFORE_080300
+#endif
+
+#ifndef HAVE_PQISTHREADSAFE
+#define PG_BEFORE_080200
+#endif
+
+#ifndef HAVE_LO_CREATE
+#define PG_BEFORE_080100
+#endif
+
+#ifndef HAVE_PQPREPARE
+#define PG_BEFORE_080000
+#endif
+
+#ifndef HAVE_PQEXECPARAMS
+#define PG_BEFORE_070400
+#endif
+
+#ifndef HAVE_PQESCAPESTRINGCONN
+#define PG_BEFORE_070300
+#error PostgreSQL client version too old, requires 7.3 or later.
+#endif
+
+/* This is necessary because NAMEDATALEN is defined in 
+ * pg_config_manual.h in 8.3, and that include file doesn't
+ * exist before 7.4
+ */
+#ifndef PG_BEFORE_070400
+#include "pg_config_manual.h"
+#endif
+
+#ifndef PG_DIAG_INTERNAL_POSITION
+#define PG_DIAG_INTERNAL_POSITION 'p'
+#endif /* PG_DIAG_INTERNAL_POSITION */
+
+#ifndef PG_DIAG_INTERNAL_QUERY
+#define PG_DIAG_INTERNAL_QUERY  'q'
+#endif /* PG_DIAG_INTERNAL_QUERY */
+
+#ifdef PG_BEFORE_080300
+
+#ifndef HAVE_PG_ENCODING_TO_CHAR
+#define pg_encoding_to_char(x) "SQL_ASCII"
+#else
+ /* Some versions ofPostgreSQL prior to 8.3 define pg_encoding_to_char
+  * but do not declare it in a header file, so this declaration will
+  * eliminate an unecessary warning
+  */
+extern char* pg_encoding_to_char(int);
+#endif /* HAVE_PG_ENCODING_TO_CHAR */
+
+int PQconnectionNeedsPassword(PGconn *conn);
+int PQconnectionUsedPassword(PGconn *conn);
+int lo_truncate(PGconn *conn, int fd, size_t len);
+
+#endif /* PG_BEFORE_080300 */
+
+#ifdef PG_BEFORE_080200
+int PQisthreadsafe(void);
+int PQnparams(const PGresult *res);
+Oid PQparamtype(const PGresult *res, int param_number);
+PGresult * PQdescribePrepared(PGconn *conn, const char *stmtName);
+PGresult * PQdescribePortal(PGconn *conn, const char *portalName);
+int PQsendDescribePrepared(PGconn *conn, const char *stmtName);
+int PQsendDescribePortal(PGconn *conn, const char *portalName);
+char *PQencryptPassword(const char *passwd, const char *user);
+#endif /* PG_BEFORE_080200 */
+
+#ifdef PG_BEFORE_080100
+Oid lo_create(PGconn *conn, Oid lobjId);
+#endif /* PG_BEFORE_080100 */
+
+#ifdef PG_BEFORE_080000
+PGresult *PQprepare(PGconn *conn, const char *stmtName, const char *query,
+	int nParams, const Oid *paramTypes);
+int PQsendPrepare(PGconn *conn, const char *stmtName, const char *query,
+	int nParams, const Oid *paramTypes);
+int PQserverVersion(const PGconn* conn);
+#endif /* PG_BEFORE_080000 */
+
+#ifdef PG_BEFORE_070400
+
+#define PG_DIAG_SEVERITY        'S'
+#define PG_DIAG_SQLSTATE        'C'
+#define PG_DIAG_MESSAGE_PRIMARY 'M'
+#define PG_DIAG_MESSAGE_DETAIL  'D'
+#define PG_DIAG_MESSAGE_HINT    'H'
+#define PG_DIAG_STATEMENT_POSITION 'P'
+#define PG_DIAG_CONTEXT         'W'
+#define PG_DIAG_SOURCE_FILE     'F'
+#define PG_DIAG_SOURCE_LINE     'L'
+#define PG_DIAG_SOURCE_FUNCTION 'R'
+
+#define PQfreemem(ptr) free(ptr)
+#define PGNOTIFY_EXTRA(notify) ""
+
+/* CONNECTION_SSL_STARTUP was added to an enum type
+ * after 7.3. For 7.3 in order to compile, we just need
+ * it to evaluate to something that is not present in that
+ * enum.
+ */
+#define CONNECTION_SSL_STARTUP 1000000
+
+typedef void (*PQnoticeReceiver) (void *arg, const PGresult *res);
+
+typedef enum
+{
+	PQERRORS_TERSE,		/* single-line error messages */
+	PQERRORS_DEFAULT,	/* recommended style */
+	PQERRORS_VERBOSE	/* all the facts, ma'am */
+} PGVerbosity;
+
+typedef enum
+{
+	PQTRANS_IDLE,		/* connection idle */
+	PQTRANS_ACTIVE,		/* command in progress */
+	PQTRANS_INTRANS,	/* idle, within transaction block */
+	PQTRANS_INERROR,	/* idle, within failed transaction */
+	PQTRANS_UNKNOWN		/* cannot determine status */
+} PGTransactionStatusType;
+
+PGresult *PQexecParams(PGconn *conn, const char *command, int nParams, 
+	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
+	const int *paramFormats, int resultFormat);
+PGTransactionStatusType PQtransactionStatus(const PGconn *conn);
+char *PQparameterStatus(const PGconn *conn, const char *paramName);
+int PQprotocolVersion(const PGconn *conn);
+PGresult *PQexecPrepared(PGconn *conn, const char *stmtName, int nParams, 
+	const char * const *ParamValues, const int *paramLengths, const int *paramFormats,
+	int resultFormat);
+int PQsendQueryParams(PGconn *conn, const char *command, int nParams,
+	const Oid *paramTypes, const char * const * paramValues, const int *paramLengths, 
+	const int *paramFormats, int resultFormat);
+int PQsendQueryPrepared(PGconn *conn, const char *stmtName, int nParams, 
+	const char * const *ParamValues, const int *paramLengths, const int *paramFormats,
+	int resultFormat);
+int PQputCopyData(PGconn *conn, const char *buffer, int nbytes);
+int PQputCopyEnd(PGconn *conn, const char *errormsg);
+int PQgetCopyData(PGconn *conn, char **buffer, int async);
+PGVerbosity PQsetErrorVerbosity(PGconn *conn, PGVerbosity verbosity);
+Oid PQftable(const PGresult *res, int column_number);
+int PQftablecol(const PGresult *res, int column_number);
+int PQfformat(const PGresult *res, int column_number);
+char *PQresultErrorField(const PGresult *res, int fieldcode);
+PQnoticeReceiver PQsetNoticeReceiver(PGconn *conn, PQnoticeReceiver proc, void *arg);
+
+#else
+#define PGNOTIFY_EXTRA(notify) ((notify)->extra)
+#endif /* PG_BEFORE_070400 */
+
+#ifdef PG_BEFORE_070300
+#error unsupported postgresql version, requires 7.3 or later.
+int PQsetClientEncoding(PGconn *conn, const char *encoding)
+size_t PQescapeString(char *to, const char *from, size_t length);
+unsigned char * PQescapeBytea(const unsigned char *bintext, size_t binlen, size_t *bytealen);
+unsigned char * PQunescapeBytea(const unsigned char *strtext, size_t *retbuflen);
+size_t PQescapeStringConn(PGconn *conn, char *to, const char *from, 
+	size_t length, int *error);
+unsigned char *PQescapeByteaConn(PGconn *conn, const unsigned char *from, 
+	size_t from_length, size_t *to_length);
+#endif /* PG_BEFORE_070300 */
+
+#endif /* __compat_h */

data/ext/mingw/Rakefile

@@ -0,0 +1,24 @@
+# We can't use Ruby's standard build procedures
+# on Windows because the Ruby executable is
+# built with VC++ while here we want to build
+# with MingW.  So just roll our own...
+
+require 'fileutils'
+require 'rbconfig'
+
+EXTENSION_NAME = "pg.#{Config::CONFIG["DLEXT"]}"
+
+# This is called when the Windows GEM is installed!
+task :install do
+  # Gems will pass these two environment variables:
+  # RUBYARCHDIR=#{dest_path}
+  # RUBYLIBDIR=#{dest_path}
+
+  dest_path = ENV['RUBYLIBDIR']
+  mkdir_p(dest_path)
+  
+  # Copy the extension
+  cp(EXTENSION_NAME, dest_path)
+end
+
+task :default => :install

data/ext/mingw/build.rake

@@ -0,0 +1,40 @@
+# We can't use Ruby's standard build procedures
+# on Windows because the Ruby executable is
+# built with VC++ while here we want to build
+# with MingW.  So just roll our own...
+
+require 'rake/clean'
+require 'rbconfig'
+
+RUBY_INCLUDE_DIR = Config::CONFIG["archdir"]
+RUBY_BIN_DIR = Config::CONFIG["bindir"]
+RUBY_LIB_DIR = Config::CONFIG["libdir"]
+RUBY_SHARED_LIB = Config::CONFIG["LIBRUBY"]
+RUBY_SHARED_DLL = RUBY_SHARED_LIB.gsub(/lib$/, 'dll')
+    
+EXTENSION_NAME = "pg.#{Config::CONFIG["DLEXT"]}"
+
+CLEAN.include('*.o')
+CLOBBER.include(EXTENSION_NAME)
+
+task :default => "pg"
+
+DEFINES = "-DHAVE_LIBPQ_FE_H -DHAVE_LIBPQ_LIBPQ_FS_H -DHAVE_PQCONNECTIONUSEDPASSWORD -DHAVE_PQISTHREADSAFE -DHAVE_LO_CREATE -DHAVE_PQPREPARE -DHAVE_PQEXECPARAMS -DHAVE_PQESCAPESTRING -DHAVE_PQESCAPESTRINGCONN -DHAVE_PG_ENCODING_TO_CHAR -DHAVE_PQSETCLIENTENCODING"
+LIBS = "-lpq -lm"
+SRC = FileList['../*.c']
+OBJ = SRC.collect do |file_name|
+  File.basename(file_name).ext('o')
+end
+
+SRC.each do |srcfile|
+  objfile = File.basename(srcfile).ext('o')
+  file objfile => srcfile do
+    command = "gcc -c -O2 -Wall #{DEFINES} -o #{objfile} -I/usr/local/include #{srcfile} -I#{RUBY_INCLUDE_DIR}"
+    sh "sh -c '#{command}'" 
+  end
+end
+
+file "pg" => OBJ do
+  command = "gcc -shared -o #{EXTENSION_NAME} #{OBJ} -L/usr/local/lib #{LIBS} #{RUBY_BIN_DIR}/#{RUBY_SHARED_DLL}"
+  sh "sh -c '#{command}'" 
+end

data/ext/mkrf_config.rb

@@ -0,0 +1,138 @@
+require 'rubygems'
+require 'mkrf'
+
+pg_config_command =
+  if RUBY_PLATFORM.match(/win32/)
+    "pg_config --bindir > nul"
+  else
+    "pg_config --bindir > /dev/null"
+  end
+
+unless system(pg_config_command)
+	$stderr.write("ERROR: can't find pg_config.\n")
+	$stderr.write("HINT: Make sure pg_config is in your PATH\n")
+	exit 1
+end
+
+$functions = %w[
+	lo_create
+    PQconnectionUsedPassword
+    PQisthreadsafe
+    PQprepare
+    PQexecParams
+    PQescapeString
+    PQescapeStringConn
+    lo_create
+    pg_encoding_to_char
+    PQsetClientEncoding
+]
+
+# OS X compatibility
+if(PLATFORM =~ /darwin/) then
+	# test if postgresql is probably universal
+	bindir = escape_path(IO.popen("pg_config --bindir").readline.chomp)
+	Open3.popen3('file',"#{bindir}/pg_config") do |the_in, the_out, the_err|
+		filetype = the_out.readline.chomp
+	end
+	# if it's not universal, ARCHFLAGS should be set
+	if((filetype !~ /universal binary/) && ENV['ARCHFLAGS'].nil?) then
+		arch_tmp = (IO.popen("uname -p").readline.chomp rescue nil)
+		if(arch_tmp == 'powerpc')
+			arch = 'ppc'
+		else
+			arch = 'i386'
+		end
+		$stderr.write %{
+		===========   WARNING   ===========
+		
+		You are building this extension on OS X without setting the 
+		ARCHFLAGS environment variable, and PostgreSQL does not appear 
+		to have been built as a universal binary. If you are seeing this 
+		message, that means that the build will probably fail.
+
+		Try setting the environment variable ARCHFLAGS 
+		to '-arch #{arch}' before building.
+
+		For example:
+		(in bash) $ export ARCHFLAGS='-arch #{arch}'
+		(in tcsh) % setenv ARCHFLAGS '-arch #{arch}'
+
+		Then try building again.
+
+		===================================
+		}
+		# We don't exit here. Who knows? It might build.
+	end
+end
+
+if RUBY_VERSION < '1.8'
+	puts 'This library is for ruby-1.8 or higher.'
+	exit 1
+end
+
+def escape_path(path)
+	if(PLATFORM =~ /mswin|mingw/) then
+		'"' + path + '"'
+	else
+		path.gsub(%r{([^a-zA-Z0-9/._-])}, "\\\\\\1")
+	end
+end
+
+def pg_config(type)
+	IO.popen("pg_config --#{type}dir").readline.chomp
+end
+
+def config_value(type)
+	escape_path(ENV["POSTGRES_#{type.upcase}"] || pg_config(type))
+end
+
+Mkrf::Generator.new('pg', '*.c', 
+		{
+			:includes => [config_value('include'), Config::CONFIG['includedir'], 
+					Config::CONFIG["archdir"], Config::CONFIG['sitelibdir'], "."],
+			:library_paths => [config_value('lib')],
+			# must set loaded_libs to work around a mkrf bug on some platforms
+			:loaded_libs => []
+		}
+	) do |g|
+
+	$stdout.write("checking for libpq-fe.h... ")
+	if g.include_header('libpq-fe.h') &&
+	   g.include_header('libpq/libpq-fs.h')
+	then
+		puts 'yes'
+	else
+		puts 'no'
+		puts 'Could not find PostgreSQL headers: ' +
+				'Rakefile not created'
+		exit 1
+	end
+
+	$stdout.write("checking for libpq... ")
+	# we have to check a few possible names to account
+	# for building on windows
+	if g.include_library('pq') ||
+	   g.include_library('libpq') ||
+	   g.include_library('ms/libpq')
+	then
+		puts 'yes'
+	else
+		puts 'no'
+		puts 'Could not find PostgreSQL client library: ' +
+				'Rakefile not created'
+		exit 1
+	end
+
+	$functions.each do |func|
+		$stdout.write("checking for #{func}()... ")
+		if(g.has_function?(func)) then
+			g.add_define("HAVE_#{func.upcase}")
+			puts 'yes'
+		else
+			puts 'no'
+		end
+	end
+
+	puts "creating Rakefile"
+end
+

data/ext/pg-m17n3.patch

@@ -0,0 +1,535 @@
+Index: ext/pg.c
+===================================================================
+--- ext/pg.c	(revision 199)
++++ ext/pg.c	(working copy)
+@@ -13,6 +13,9 @@
+ ************************************************/
+ 
+ #include "pg.h"
++#if defined(HAVE_RUBY_ENCODING_H) && HAVE_RUBY_ENCODING_H
++# define M17N_SUPPORTED
++#endif
+ 
+ #define rb_define_singleton_alias(klass,new,old) rb_define_alias(rb_singleton_class(klass),new,old)
+ 
+@@ -52,9 +55,18 @@
+ static VALUE pgresult_clear(VALUE self);
+ static VALUE pgresult_aref(VALUE self, VALUE index);
+ 
++#ifdef M17N_SUPPORTED
++# define ASSOCIATE_INDEX(obj, index_holder) rb_enc_associate_index((obj), enc_get_index((index_holder)))
++static rb_encoding * pgconn_get_client_encoding_as_rb_encoding(PGconn* conn);
++static int enc_get_index(VALUE val);
++#else
++# define ASSOCIATE_INDEX(obj, index_holder) /* nothing */
++#endif
++
+ static PQnoticeReceiver default_notice_receiver = NULL;
+ static PQnoticeProcessor default_notice_processor = NULL;
+ 
++
+ /*
+  * Used to quote the values passed in a Hash to PGconn.init
+  * when building the connection string.
+@@ -115,11 +127,23 @@
+ 	return result;
+ }
+ 
++#ifdef M17N_SUPPORTED
+ static VALUE
++new_pgresult(PGresult *result, PGconn *conn)
++{
++	 VALUE val = Data_Wrap_Struct(rb_cPGresult, NULL, free_pgresult, result);
++	 rb_encoding *enc = pgconn_get_client_encoding_as_rb_encoding(conn);
++	 rb_enc_set_index(val, rb_enc_to_index(enc));
++	 return val;
++}
++#else
++static VALUE
+ new_pgresult(PGresult *result)
+ {
+ 	return Data_Wrap_Struct(rb_cPGresult, NULL, free_pgresult, result);
+ }
++# define new_pgresult(result, conn) new_pgresult((result))
++#endif
+ 
+ /*
+  * Raises appropriate exception if PGresult is
+@@ -923,7 +947,7 @@
+ 	/* If called with no parameters, use PQexec */
+ 	if(NIL_P(params)) {
+ 		result = PQexec(conn, StringValuePtr(command));
+-		rb_pgresult = new_pgresult(result);
++		rb_pgresult = new_pgresult(result, conn);
+ 		pgresult_check(self, rb_pgresult);
+ 		if (rb_block_given_p()) {
+ 			return rb_ensure(yield_pgresult, rb_pgresult, 
+@@ -1007,7 +1031,7 @@
+ 	xfree(paramLengths);
+ 	xfree(paramFormats);
+ 
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	pgresult_check(self, rb_pgresult);
+ 	if (rb_block_given_p()) {
+ 		return rb_ensure(yield_pgresult, rb_pgresult, 
+@@ -1070,7 +1094,7 @@
+ 
+ 	xfree(paramTypes);
+ 
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	pgresult_check(self, rb_pgresult);
+ 	return rb_pgresult;
+ }
+@@ -1189,7 +1213,7 @@
+ 	xfree(paramLengths);
+ 	xfree(paramFormats);
+ 
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	pgresult_check(self, rb_pgresult);
+ 	if (rb_block_given_p()) {
+ 		return rb_ensure(yield_pgresult, rb_pgresult, 
+@@ -1220,7 +1244,7 @@
+ 		stmt = StringValuePtr(stmt_name);
+ 	}
+ 	result = PQdescribePrepared(conn, stmt);
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	pgresult_check(self, rb_pgresult);
+ 	return rb_pgresult;
+ }
+@@ -1248,7 +1272,7 @@
+ 		stmt = StringValuePtr(stmt_name);
+ 	}
+ 	result = PQdescribePortal(conn, stmt);
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	pgresult_check(self, rb_pgresult);
+ 	return rb_pgresult;
+ }
+@@ -1276,7 +1300,7 @@
+ 	VALUE rb_pgresult;
+ 	PGconn *conn = get_pgconn(self);
+ 	result = PQmakeEmptyPGresult(conn, NUM2INT(status));
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	pgresult_check(self, rb_pgresult);
+ 	return rb_pgresult;
+ }
+@@ -1796,7 +1820,7 @@
+ 	result = PQgetResult(conn);
+ 	if(result == NULL)
+ 		return Qnil;
+-	rb_pgresult = new_pgresult(result);
++	rb_pgresult = new_pgresult(result, conn);
+ 	if (rb_block_given_p()) {
+ 		return rb_ensure(yield_pgresult, rb_pgresult,
+ 			pgresult_clear, rb_pgresult);
+@@ -2317,18 +2341,18 @@
+ 	
+ 	if (rb_block_given_p()) {
+ 		result = PQexec(conn, "BEGIN");
+-		rb_pgresult = new_pgresult(result);
++		rb_pgresult = new_pgresult(result, conn);
+ 		pgresult_check(self, rb_pgresult);
+ 		rb_protect(rb_yield, self, &status);
+ 		if(status == 0) {
+ 			result = PQexec(conn, "COMMIT");
+-			rb_pgresult = new_pgresult(result);
++			rb_pgresult = new_pgresult(result, conn);
+ 			pgresult_check(self, rb_pgresult);
+ 		}
+ 		else {
+ 			/* exception occurred, ROLLBACK and re-raise */
+ 			result = PQexec(conn, "ROLLBACK");
+-			rb_pgresult = new_pgresult(result);
++			rb_pgresult = new_pgresult(result, conn);
+ 			pgresult_check(self, rb_pgresult);
+ 			rb_jump_tag(status);
+ 		}
+@@ -2830,7 +2854,9 @@
+ static VALUE
+ pgresult_res_status(VALUE self, VALUE status)
+ {
+-	return rb_tainted_str_new2(PQresStatus(NUM2INT(status)));
++	VALUE ret = rb_tainted_str_new2(PQresStatus(NUM2INT(status)));
++	ASSOCIATE_INDEX(ret, self);
++	return ret;
+ }
+ 
+ /*
+@@ -2842,7 +2868,9 @@
+ static VALUE
+ pgresult_result_error_message(VALUE self)
+ {
+-	return rb_tainted_str_new2(PQresultErrorMessage(get_pgresult(self)));
++	VALUE ret = rb_tainted_str_new2(PQresultErrorMessage(get_pgresult(self)));
++	ASSOCIATE_INDEX(ret, self);
++	return ret;
+ }
+ 
+ /*
+@@ -2870,7 +2898,9 @@
+ {
+ 	PGresult *result = get_pgresult(self);
+ 	int fieldcode = NUM2INT(field);
+-	return rb_tainted_str_new2(PQresultErrorField(result,fieldcode));
++	VALUE ret = rb_tainted_str_new2(PQresultErrorField(result,fieldcode));
++	ASSOCIATE_INDEX(ret, self);
++	return ret;
+ }
+ 
+ /*
+@@ -2920,6 +2950,7 @@
+ static VALUE
+ pgresult_fname(VALUE self, VALUE index)
+ {
++	VALUE fname;
+ 	PGresult *result;
+ 	int i = NUM2INT(index);
+ 
+@@ -2927,7 +2958,9 @@
+ 	if (i < 0 || i >= PQnfields(result)) {
+ 		rb_raise(rb_eArgError,"invalid field number %d", i);
+ 	}
+-	return rb_tainted_str_new2(PQfname(result, i));
++	fname = rb_tainted_str_new2(PQfname(result, i));
++	ASSOCIATE_INDEX(fname, self);
++	return fname;
+ }
+ 
+ /*
+@@ -3094,6 +3127,7 @@
+ static VALUE
+ pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
+ {
++	VALUE ret;
+ 	PGresult *result;
+ 	int i = NUM2INT(tup_num);
+ 	int j = NUM2INT(field_num);
+@@ -3107,8 +3141,10 @@
+ 	}
+ 	if(PQgetisnull(result, i, j))
+ 		return Qnil;
+-	return rb_tainted_str_new(PQgetvalue(result, i, j), 
++	ret = rb_tainted_str_new(PQgetvalue(result, i, j), 
+ 				PQgetlength(result, i, j));
++	ASSOCIATE_INDEX(ret, self);
++	return ret;
+ }
+ 
+ /*
+@@ -3200,7 +3236,9 @@
+ static VALUE
+ pgresult_cmd_status(VALUE self)
+ {
+-	return rb_tainted_str_new2(PQcmdStatus(get_pgresult(self)));
++	VALUE ret = rb_tainted_str_new2(PQcmdStatus(get_pgresult(self)));
++	ASSOCIATE_INDEX(ret, self);
++	return ret;
+ }
+ 
+ /*
+@@ -3264,12 +3302,14 @@
+ 	tuple = rb_hash_new();
+ 	for(field_num = 0; field_num < PQnfields(result); field_num++) {
+ 		fname = rb_tainted_str_new2(PQfname(result,field_num));
++		ASSOCIATE_INDEX(fname, self);
+ 		if(PQgetisnull(result, tuple_num, field_num)) {
+ 			rb_hash_aset(tuple, fname, Qnil);
+ 		}
+ 		else {
+ 			val = rb_tainted_str_new(PQgetvalue(result, tuple_num, field_num),
+ 				PQgetlength(result, tuple_num, field_num));
++			ASSOCIATE_INDEX(val, self);
+ 			rb_hash_aset(tuple, fname, val);
+ 		}
+ 	}
+@@ -3311,11 +3351,276 @@
+ 	n = PQnfields(result);
+ 	ary = rb_ary_new2(n);
+ 	for (i=0;i<n;i++) {
+-		rb_ary_push(ary, rb_tainted_str_new2(PQfname(result, i)));
++		VALUE val = rb_tainted_str_new2(PQfname(result, i));
++		ASSOCIATE_INDEX(val, self);
++		rb_ary_push(ary, val);
+ 	}
+ 	return ary;
+ }
+ 
++#ifdef M17N_SUPPORTED
++/**
++ * The mapping from canonical encoding names in PostgreSQL to ones in Ruby.
++ */
++static const char * const (enc_pg2ruby_mapping[][2]) = {
++	    {"BIG5",          "Big5"       },
++	    {"EUC_CN",        "GB2312"     },
++	    {"EUC_JP",        "EUC-JP"     },
++	    {"EUC_JIS_2004",  "EUC-JP"     },
++	    {"EUC_KR",        "EUC-KR"     },
++	    {"EUC_TW",        "EUC-TW"     },
++	    {"GB18030",       "GB18030"    },
++	    {"GBK",           "GBK"        },
++	    {"ISO_8859_5",    "ISO-8859-5" },
++	    {"ISO_8859_6",    "ISO-8859-6" },
++	    {"ISO_8859_7",    "ISO-8859-7" },
++	    {"ISO_8859_8",    "ISO-8859-8" },
++	    /* {"JOHAB",         "JOHAB"     }, dummy */
++	    {"KOI8",          "KOI8-U"     },
++	    {"LATIN1",        "ISO-8859-1" },
++	    {"LATIN2",        "ISO-8859-2" },
++	    {"LATIN3",        "ISO-8859-3" },
++	    {"LATIN4",        "ISO-8859-4" },
++	    {"LATIN5",        "ISO-8859-5" },
++	    {"LATIN6",        "ISO-8859-6" },
++	    {"LATIN7",        "ISO-8859-7" },
++	    {"LATIN8",        "ISO-8859-8" },
++	    {"LATIN9",        "ISO-8859-9" },
++	    {"LATIN10",       "ISO-8859-10" },
++	    {"MULE_INTERNAL", "Emacs-Mule" },
++	    {"SJIS",          "Windows-31J" },
++	    {"SHIFT_JIS_2004","Windows-31J" },
++	    /*{"SQL_ASCII",     NULL        },  special case*/
++	    {"UHC",           "CP949"       },
++	    {"UTF8",          "UTF-8"       },
++	    {"WIN866",        "IBM866"      },
++	    {"WIN874",        "Windows-874" },
++	    {"WIN1250",       "Windows-1250"},
++	    {"WIN1251",       "Windows-1251"},
++	    {"WIN1252",       "Windows-1252"},
++	    {"WIN1253",       "Windows-1253"},
++	    {"WIN1254",       "Windows-1254"},
++	    {"WIN1255",       "Windows-1255"},
++	    {"WIN1256",       "Windows-1256"},
++	    {"WIN1257",       "Windows-1257"},
++	    {"WIN1258",       "Windows-1258"}
++};
++
++
++/*
++ * 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;
++
++static int 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;
++}
++
++extern int rb_enc_alias(const char *alias, const char *orig); /* declaration missing in Ruby 1.9.1 */
++static rb_encoding *
++find_or_create_johab(void)
++{
++	static const char * const aliases[] = { "JOHAB", "Windows-1361", "CP1361" };
++	int enc_index;
++	int i;
++	for (i = 0; i < sizeof(aliases)/sizeof(aliases[0]); ++i) {
++		enc_index = rb_enc_find_index(aliases[i]);
++		if (enc_index > 0) return rb_enc_from_index(enc_index);
++	}
++
++	enc_index = rb_define_dummy_encoding(aliases[0]);
++	for (i = 1; i < sizeof(aliases)/sizeof(aliases[0]); ++i) {
++		rb_enc_alias(aliases[i], aliases[0]);
++	}
++	return rb_enc_from_index(enc_index);
++}
++
++/*
++ * Returns the client_encoding of the given connection as a rb_encoding*
++ *
++ * * returns NULL if the client encoding is 'SQL_ASCII'.
++ * * returns ASCII-8BIT if the client encoding is unknown.
++ */
++static rb_encoding *
++pgconn_get_client_encoding_as_rb_encoding(PGconn* conn)
++{
++	rb_encoding *enc;
++	int enc_id = PQclientEncoding(conn);
++
++	if (st_lookup(enc_pg2ruby, (st_data_t)enc_id, (st_data_t*)&enc)) {
++		return enc;
++	}
++	else {
++		int i;
++		const char *name = pg_encoding_to_char(enc_id);
++		if (strcmp("SQL_ASCII", name) == 0) {
++			enc = NULL;
++			goto cache;
++		}
++		for (i = 0; i < sizeof(enc_pg2ruby_mapping)/sizeof(enc_pg2ruby_mapping[0]); ++i) {
++			if (strcmp(name, enc_pg2ruby_mapping[i][0]) == 0) {
++				enc = rb_enc_find(enc_pg2ruby_mapping[i][1]);
++				goto cache;
++			}
++		}
++
++		/* Ruby 1.9.1 does not supoort JOHAB */
++		if (strcmp(name, "JOHAB") == 0) {
++			enc = find_or_create_johab();
++			goto cache;
++		}
++
++		enc = rb_ascii8bit_encoding();
++	}
++cache:
++	st_insert(enc_pg2ruby, (st_data_t)enc_id, (st_data_t)enc);
++	return enc;
++}
++
++/*
++ * call-seq:
++ *   conn.internal_encoding() -> Encoding
++ *
++ * defined in Ruby 1.9 or later.
++ *
++ * Returns:
++ * * an Encoding - client_encoding of the connection as a Ruby's Encoding object.
++ * * nil - the client_encoding is 'SQL_ASCII'
++ */
++static VALUE
++pgconn_internal_encoding(VALUE self)
++{
++	return rb_enc_from_encoding(pgconn_get_client_encoding_as_rb_encoding(get_pgconn(self)));
++}
++
++static VALUE pgconn_external_encoding(VALUE self);
++
++/*
++ * call-seq:
++ *   conn.internal_encoding = value
++ *
++ * A wrapper of +PGconn#set_client_encoding+.
++ * defined in Ruby 1.9 or later.
++ *
++ * +value+ can be one of:
++ * * an Encoding
++ * * a String - a name of Encoding
++ * * +nil+ - sets 'SQL_ASCII' to the client_encoding.
++ */
++static VALUE
++pgconn_internal_encoding_set(VALUE self, VALUE enc)
++{
++	if (NIL_P(enc)) {
++		pgconn_set_client_encoding(self, rb_usascii_str_new_cstr("SQL_ASCII"));
++		return enc;
++	}
++	else if (TYPE(enc) == T_STRING && strcasecmp("JOHAB", RSTRING_PTR(enc)) == 0) {
++		pgconn_set_client_encoding(self, rb_usascii_str_new_cstr("JOHAB"));
++		return enc;
++	}
++	else {
++		int i;
++		const char *name; 
++		name = rb_enc_name(rb_to_encoding(enc));
++
++		/* sequential search becuase rarely called */
++		for (i = 0; i < sizeof(enc_pg2ruby_mapping)/sizeof(enc_pg2ruby_mapping[0]); ++i) {
++			if (strcmp(name, enc_pg2ruby_mapping[i][1]) == 0) {
++				if (PQsetClientEncoding(get_pgconn(self), enc_pg2ruby_mapping[i][0]) == -1) {
++					VALUE server_encoding = pgconn_external_encoding(self);
++					rb_raise(rb_eEncCompatError, "imcompatible character encodings: %s and %s",
++							rb_enc_name(rb_to_encoding(server_encoding)),
++							enc_pg2ruby_mapping[i][0]);
++				}
++				return enc;
++			}
++		}
++
++		/* Ruby 1.9.1 does not support JOHAB */
++		if (strcasecmp(name, "JOHAB") == 0) {
++			pgconn_set_client_encoding(self, rb_usascii_str_new_cstr("JOHAB"));
++			return enc;
++		}
++	}
++
++	enc = rb_inspect(enc);
++	rb_raise(rb_ePGError, "unknown encoding: %s", StringValuePtr(enc));
++}
++
++
++
++static VALUE enc_server_encoding_getvalue(VALUE pgresult)
++{
++	return pgresult_getvalue(pgresult, INT2FIX(0), INT2FIX(0));
++}
++
++/*
++ * call-seq:
++ *   conn.external_encoding() -> Encoding
++ *
++ * defined in Ruby 1.9 or later.
++ * * Returns the server_encoding of the connected database as a Ruby's Encoding object.
++ * * Maps 'SQL_ASCII' to ASCII-8BIT.
++ */
++static VALUE
++pgconn_external_encoding(VALUE self)
++{
++	VALUE enc;
++	enc = rb_iv_get(self, "@external_encoding");
++	if (RTEST(enc)) {
++		return enc;
++	}
++	else {
++		int i;
++		VALUE query = rb_usascii_str_new_cstr("SHOW server_encoding");
++		VALUE pgresult = pgconn_exec(1, &query, self);
++		VALUE enc_name = rb_ensure(enc_server_encoding_getvalue, pgresult, pgresult_clear, pgresult);
++
++		if (strcmp("SQL_ASCII", StringValuePtr(enc_name)) == 0) {
++			enc = rb_enc_from_encoding(rb_ascii8bit_encoding());
++			goto cache;
++		}
++		for (i = 0; i < sizeof(enc_pg2ruby_mapping)/sizeof(enc_pg2ruby_mapping[0]); ++i) {
++			if (strcmp(StringValuePtr(enc_name), enc_pg2ruby_mapping[i][0]) == 0) {
++				enc = rb_enc_from_encoding(rb_enc_find(enc_pg2ruby_mapping[i][1]));
++				goto cache;
++			}
++		}
++
++		/* Ruby 1.9.1 does not supoort JOHAB */
++		if (strcmp(StringValuePtr(enc_name), "JOHAB") == 0) {
++			enc = rb_enc_from_encoding(find_or_create_johab());
++			goto cache;
++		}
++
++		/* fallback */
++		enc = rb_enc_from_encoding(rb_enc_find(StringValuePtr(enc_name)));
++	}
++
++cache:
++	rb_iv_set(self, "@external_encoding", enc);
++	return enc;
++}
++
++static void
++init_m17n(void)
++{
++	enc_pg2ruby = st_init_numtable();
++	s_id_index = rb_intern("@encoding");
++	rb_define_method(rb_cPGconn, "internal_encoding", pgconn_internal_encoding, 0);
++	rb_define_method(rb_cPGconn, "internal_encoding=", pgconn_internal_encoding_set, 1);
++	rb_define_method(rb_cPGconn, "external_encoding", pgconn_external_encoding, 0);
++}
++
++
++#endif
+ /**************************************************************************/
+ 
+ void
+@@ -3566,4 +3871,7 @@
+ 	rb_define_method(rb_cPGresult, "each", pgresult_each, 0);
+ 	rb_define_method(rb_cPGresult, "fields", pgresult_fields, 0);
+ 
++#ifdef M17N_SUPPORTED
++        init_m17n();
++#endif
+ }