pg 0.8.0 → 0.9.0.pre156

data/Rakefile.local

@@ -0,0 +1,239 @@
+#!rake
+
+require 'rake/extensiontask'
+require 'rake/extensioncompiler'
+require 'rbconfig'
+
+# C extension constants
+EXT_MAKEFILE  = EXTDIR + 'Makefile'
+EXT_SOURCES   = FileList[ EXTDIR + '*.c' ]
+EXT_SO        = EXTDIR + "pg.#{CONFIG['DLEXT']}"
+
+SITEARCH_DIR  = LIBDIR + Config::CONFIG['sitearch']
+
+NUM_CPUS = if File.exist?('/proc/cpuinfo')
+	File.read('/proc/cpuinfo').scan('processor').length
+else
+	1
+end
+
+# Cross-compilation constants
+COMPILE_HOME = File.expand_path("~/.rake-compiler")
+OPENSSL_VERSION = ENV['OPENSSL_VERSION'] || '0.9.8l'
+POSTGRESQL_VERSION = ENV['POSTGRESQL_VERSION'] || '8.4.2'
+
+CROSS_PREFIX = if RUBY_PLATFORM.include?( 'darwin' )
+	'i386-mingw32'
+else
+	'i586-mingw32msvc'
+end
+
+
+#####################################################################
+###	T A S K S
+#####################################################################
+
+# Make both the default task and the spec task depend on building the extension
+task :local => :compile
+task :spec => :compile
+namespace :spec do
+	task :doc   => [ :compile ]
+	task :quiet => [ :compile ]
+	task :html  => [ :compile ]
+	task :text  => [ :compile ]
+end
+
+ENV['RUBY_CC_VERSION'] = '1.8.6:1.9.1'
+
+Rake::ExtensionTask.new do |ext|
+	ext.name = 'pg_ext'
+	ext.gem_spec = GEMSPEC
+	ext.ext_dir = 'ext'
+	ext.lib_dir = 'lib'
+	ext.source_pattern = "*.{c,h}"
+
+	# If there's an explicit 'compile' argument, use everything after it as options.
+	if offset = ARGV.index( 'compile' )
+		trace "config options = %p" % [ ARGV[(offset + 1)..-1] ]
+		ext.config_options = ARGV[ (offset + 1)..-1 ]
+	# Otherwise, just grab everything from the first option onward
+	elsif offset = ARGV.index( ARGV.find {|arg| arg =~ /^--/ } )
+		trace "config options = %p" % [ ARGV[offset..-1] ]
+		ext.config_options = ARGV[ offset..-1 ]
+	else
+		trace "No config options (ARGV = %p)" % [ ARGV ]
+	end
+
+	ext.cross_compile = true                # enable cross compilation (requires cross compile toolchain)
+	ext.cross_platform = %w[i386-mswin32 i386-mingw32]     # forces the Windows platform instead of the default one
+
+	# configure options only for cross compile
+	ext.cross_config_options += [
+		"--with-pg-include=#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/interfaces/libpq",
+		"--with-opt-include=#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/include",
+		"--with-pg-lib=#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/interfaces/libpq",
+		"--with-opt-lib=#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}",
+		"--enable-static-build",
+	]
+
+end
+
+
+desc "Stop any Postmaster instances that remain after testing."
+task :cleanup_testing_dbs do
+    require 'spec/lib/helpers'
+    PgTestingHelpers.stop_existing_postmasters()
+    Rake::Task[:clean].invoke
+end
+
+
+#####################################################################
+###	C R O S S - C O M P I L A T I O N - T A S K S
+#####################################################################
+
+
+# define a location where sources will be stored
+directory "#{COMPILE_HOME}/sources"
+directory "#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}"
+
+# clean intermediate files and folders
+CLEAN.include("#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}")
+
+# openssl source file should be stored there
+file "#{COMPILE_HOME}/sources/openssl-#{OPENSSL_VERSION}.tar.gz" => ["#{COMPILE_HOME}/sources"] do |t|
+	# download the source file using wget or curl
+	chdir File.dirname(t.name) do
+		#http://www.openssl.org/source/openssl-0.9.8k.tar.gz
+		url = "http://www.openssl.org/source/#{File.basename(t.name)}"
+		sh "wget #{url} || curl -O #{url}"
+	end
+end
+
+# Extract the openssl builds
+file "#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}" => ["#{COMPILE_HOME}/sources/openssl-#{OPENSSL_VERSION}.tar.gz"] do |t|
+	chdir File.dirname(t.name) do
+		t.prerequisites.each { |f| sh "tar xfz ../sources/#{File.basename(f)}" }
+	end
+end
+
+# generate the makefile in a clean build location
+file "#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}/Makefile" =>
+		["#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}"] do |t|
+
+	chdir File.dirname(t.name) do
+		sh File.expand_path("Configure"), 'mingw'
+	end
+end
+
+# make
+file "#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}/libssleay32.a" => ["#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}/Makefile"] do |t|
+	chdir File.dirname(t.prerequisites.first) do
+		sh <<-EOT
+			export cross=#{CROSS_PREFIX}- &&
+			make -j#{NUM_CPUS} CC="${cross}gcc -DDSO_WIN32" AR="${cross}ar r" RANLIB="${cross}ranlib" build_libs &&
+			cp libcrypto.a libeay32.a &&
+			cp libssl.a libssleay32.a
+		EOT
+	end
+end
+
+#desc 'compile static libssl.a'
+task 'openssl-make' => ["#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}/libssleay32.a"]
+
+
+# define a location where sources will be stored
+directory "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}"
+
+# clean intermediate files and folders
+CLEAN.include("#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}")
+
+
+# postgresql source file should be stored there
+file "#{COMPILE_HOME}/sources/postgresql-#{POSTGRESQL_VERSION}.tar.bz2" => ["#{COMPILE_HOME}/sources"] do |t|
+	# download the source file using wget or curl
+	chdir File.dirname(t.name) do
+		#http://wwwmaster.postgresql.org/redir/53/h/source/v8.4.0/postgresql-8.4.0.tar.bz2
+		url = "http://wwwmaster.postgresql.org/redir/53/h/source/v#{POSTGRESQL_VERSION}/#{File.basename(t.name)}"
+		sh "wget #{url} || curl -O #{url}"
+	end
+end
+
+# Extract the postgresql sources
+file "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}" => ["#{COMPILE_HOME}/sources/postgresql-#{POSTGRESQL_VERSION}.tar.bz2"] do |t|
+	chdir File.dirname(t.name) do
+		t.prerequisites.each { |f| sh "tar xfj ../sources/#{File.basename(f)}" }
+	end
+end
+
+# generate the makefile in a clean build location
+file "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.global" =>
+		["#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}",
+		"#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}/libssleay32.a"] do |t|
+
+	options = [
+		'--target=i386-mingw32',
+		"--host=#{Rake::ExtensionCompiler.mingw_host}",
+		'--with-openssl',
+		'--without-zlib',
+		'--disable-shared',
+	]
+
+	chdir "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}" do
+		configure_path = File.expand_path("#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/configure")
+		sh <<-EOT
+			export CFLAGS=-L#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION} &&
+			export LDFLAGS=-L#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION} &&
+			export LDFLAGS_SL=-L#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION} &&
+			export "LIBS=-lwsock32 -lgdi32" &&
+			export CPPFLAGS=-I#{COMPILE_HOME}/builds/openssl-#{OPENSSL_VERSION}/include &&
+			#{configure_path} #{options.join(" ")}
+		EOT
+	end
+end
+
+# backup Makefile.shlib
+file "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.shlib.bak" => ["#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.global"] do |t|
+	cp "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.shlib", t.name
+end
+
+# patch the Makefile.shlib
+file "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.shlib" => ["#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.shlib.bak"] do |t|
+	content = File.open(t.name, 'rb') { |f| f.read }
+
+	out = ""
+
+	content.each_line do |line|
+		if line =~ /^(\s*haslibarule\s*=\s*yes)/
+			out << "##{$1}\n"
+		else
+			out << line
+		end
+	end
+
+	when_writing("Patching Makefile.shlib") {
+		File.open(t.name, 'wb') { |f| f.write(out) }
+	}
+end
+
+
+# make libpq.a
+file "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/interfaces/libpq/libpq.a" => ["#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.global", "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/Makefile.shlib"] do |t|
+	chdir File.dirname(t.name) do
+		sh "make -j#{NUM_CPUS} libpq.a PORTNAME=win32"
+	end
+end
+
+#desc 'compile static libpg.a'
+task 'postgresql-make' => ['openssl-make', "#{COMPILE_HOME}/builds/postgresql-#{POSTGRESQL_VERSION}/src/interfaces/libpq/libpq.a"]
+
+desc 'cross compile pg for win32'
+task 'cross' => [:mingw32, 'postgresql-make']
+
+task :mingw32 do
+	# Use Rake::ExtensionCompiler helpers to find the proper host
+	unless Rake::ExtensionCompiler.mingw_host then
+		warn "You need to install mingw32 cross compile functionality to be able to continue."
+		warn "Please refer to your distribution/package manager documentation about installation."
+		fail
+	end
+end

data/ext/extconf.rb

@@ -1,87 +1,126 @@
 require 'mkmf'
 
-begin
-	IO.popen("pg_config --version").readline.chomp
-rescue
-	$stderr.write("ERROR: can't find pg_config.\n")
-	$stderr.write("HINT: Make sure pg_config is in your PATH\n")
+if pgdir = with_config( 'pg' )
+	ENV['PATH'] = "#{pgdir}/bin" + File::PATH_SEPERATOR + ENV['PATH']
+end
+
+### Read the output of a command using the fork+pipe syntax so execution errors 
+### propagate to Ruby.
+def read_cmd_output( *cmd )
+	output = IO.read( '|-' ) or exec( *cmd )
+	return output.chomp
+end
+
+### Turn a version string into a Comparable binary datastructure
+def vvec( version )
+	version.split( '.' ).collect {|i| Integer(i) }.pack( 'N*' )
+end
+
+
+if vvec(RUBY_VERSION) < vvec('1.8')
+	puts 'This library is for ruby-1.8 or higher.'
 	exit 1
 end
 
-# OS X compatibility
-if(RUBY_PLATFORM =~ /darwin/) then
-	# test if postgresql is probably universal
-	bindir = (IO.popen("pg_config --bindir").readline.chomp rescue nil)
-	filetype = (IO.popen("file #{bindir}/pg_config").
-		readline.chomp rescue nil)
-	# 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'
+pgconfig = with_config( 'pg-config' ) || 'pg_config'
+if pgconfig = find_executable( pgconfig )
+	$CPPFLAGS << " -I%s" % [ read_cmd_output(pgconfig, '--includedir') ]
+	$LDFLAGS << " -L%s" % [ read_cmd_output(pgconfig, '--libdir') ]
+end
+
+# Sort out the universal vs. single-archicture build problems on MacOS X
+if RUBY_PLATFORM.include?( 'darwin' )
+	puts "MacOS X build: fixing architecture flags:"
+
+	# Only keep the '-arch <a>' flags present in both the cflags reported
+	# by pg_config and those that Ruby specifies.
+	commonflags = nil
+	if ENV['ARCHFLAGS']
+		puts "  using the value in ARCHFLAGS environment variable (%p)." % [ ENV['ARCHFLAGS'] ]
+		commonflags = ENV['ARCHFLAGS']
+	elsif pgconfig
+		puts "  finding flags common to both Ruby and PostgreSQL..."
+		archflags = []
+		pgcflags = read_cmd_output( pgconfig, '--cflags' )
+		pgcflags.scan( /-arch\s+(\S+)/ ).each do |arch|
+			puts "  testing for architecture: %p" % [ arch ]
+			archflags << "-arch #{arch}" if Config::CONFIG['CFLAGS'].index("-arch #{arch}")
 		end
-		$stderr.write %{
+
+		commonflags = archflags.join(' ')
+		puts "  common arch flags: %s" % [ commonflags ]
+	else
+		$stderr.puts %{
 		===========   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.
+		ARCHFLAGS environment variable, and pg_config wasn't found in 
+		your PATH. 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.
+		If it does, you can correct this by either including the path 
+		to 'pg_config' in your PATH or setting the environment variable 
+		ARCHFLAGS to '-arch <arch>' before building.
 
 		For example:
-		(in bash) $ export ARCHFLAGS='-arch #{arch}'
-		(in tcsh) % setenv ARCHFLAGS '-arch #{arch}'
+		(in bash) $ export PATH=/opt/local/lib/postgresql84/bin:$PATH                  
+		          $ export ARCHFLAGS='-arch x86_64'
+		(in tcsh) % set path = ( /opt/local/lib/postgresql84/bin $PATH )
+		          % setenv ARCHFLAGS '-arch x86_64'
 
 		Then try building again.
 
 		===================================
-		}
-		# We don't exit here. Who knows? It might build.
+		}.gsub( /^\t+/, '  ' )
 	end
-end
 
-if RUBY_VERSION < '1.8'
-	puts 'This library is for ruby-1.8 or higher.'
-	exit 1
-end
+	if commonflags
+		$CFLAGS.gsub!( /-arch\s+\S+ /, '' )
+		$LDFLAGS.gsub!( /-arch\s+\S+ /, '' )
+		CONFIG['LDSHARED'].gsub!( /-arch\s+\S+ /, '' )
 
-def config_value(type)
-	ENV["POSTGRES_#{type.upcase}"] || pg_config(type)
+		$CFLAGS << ' ' << commonflags
+		$LDFLAGS << ' ' << commonflags
+		CONFIG['LDSHARED'] << ' ' << commonflags
+	end
 end
 
-def pg_config(type)
-	IO.popen("pg_config --#{type}dir").readline.chomp rescue nil
-end
 
-def have_build_env
-	(have_library('pq') || have_library('libpq') || have_library('ms/libpq')) &&
-   have_header('libpq-fe.h') && have_header('libpq/libpq-fs.h')
-end
+dir_config 'pg'
 
-dir_config('pg', config_value('include'), config_value('lib'))
-
-desired_functions = %w(
-	PQconnectionUsedPassword
-	PQisthreadsafe
-	PQprepare
-	PQexecParams
-	PQescapeString
-	PQescapeStringConn
-	lo_create
-	pg_encoding_to_char 
-	PQsetClientEncoding 
-)
-
-if have_build_env
-	desired_functions.each(&method(:have_func))
-	$OBJS = ['pg.o','compat.o']
-	create_makefile("pg")
-else
-	puts 'Could not find PostgreSQL build environment (libraries & headers): Makefile not created'
+if enable_config("static-build")
+	# Link against all required libraries for static build, if they are available
+	have_library('gdi32', 'CreateDC') && append_library($libs, 'gdi32')
+	have_library('secur32') && append_library($libs, 'secur32')
+	have_library('crypto', 'BIO_new') && append_library($libs, 'crypto')
+	have_library('ssl', 'SSL_new') && append_library($libs, 'ssl')
 end
 
+
+abort "Can't find the 'libpq-fe.h header" unless have_header( 'libpq-fe.h' )
+abort "Can't find the 'libpq/libpq-fs.h header" unless have_header('libpq/libpq-fs.h')
+
+abort "Can't find the PostgreSQL client library (libpq)" unless
+	have_library( 'pq', 'PQconnectdb' ) ||
+	have_library( 'libpq', 'PQconnectdb' ) ||
+	have_library( 'ms/libpq', 'PQconnectdb' )
+
+# optional headers/functions
+have_func 'PQconnectionUsedPassword'
+have_func 'PQisthreadsafe'
+have_func 'PQprepare'
+have_func 'PQexecParams'
+have_func 'PQescapeString'
+have_func 'PQescapeStringConn'
+have_func 'lo_create'
+have_func 'pg_encoding_to_char'
+have_func 'PQsetClientEncoding'
+
+# unistd.h confilicts with ruby/win32.h when cross compiling for win32 and ruby 1.9.1
+have_header 'unistd.h' unless enable_config("static-build")
+
+$CFLAGS << ' -Wall'
+
+create_header()
+create_makefile( "pg_ext" )
+

data/ext/pg.c

@@ -8,11 +8,14 @@
   Author: ematsu
   modified at: Wed Jan 20 16:41:51 1999
 
-  $Author: jdavis $
-  $Date: 2009-03-28 09:49:43 -0700 (Sat, 28 Mar 2009) $
+  $Author$
+  $Date$
 ************************************************/
 
 #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)
 
@@ -20,6 +23,9 @@ static VALUE rb_cPGconn;
 static VALUE rb_cPGresult;
 static VALUE rb_ePGError;
 
+static const char *VERSION = "0.9.0";
+
+
 /* The following functions are part of libpq, but not
  * available from ruby-pg, because they are deprecated,
  * obsolete, or generally not useful:
@@ -51,10 +57,20 @@ static PGconn *get_pgconn(VALUE self);
 static VALUE pgconn_finish(VALUE self);
 static VALUE pgresult_clear(VALUE self);
 static VALUE pgresult_aref(VALUE self, VALUE index);
+static VALUE make_column_result_array( VALUE self, int col );
+
+#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 +131,23 @@ get_pgresult(VALUE self)
 	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
@@ -164,17 +192,6 @@ pgresult_check(VALUE rb_pgconn, VALUE rb_pgresult)
 	return;
 }
 
-static VALUE
-yield_pgresult(VALUE rb_pgresult)
-{
-	int i;
-	PGresult *result = get_pgresult(rb_pgresult);
-	for(i = 0; i < PQntuples(result); i++) {
-		return rb_yield(pgresult_aref(rb_pgresult, INT2NUM(i)));
-	}
-	return Qnil;
-}
-
 static void
 notice_receiver_proxy(void *arg, const PGresult *result)
 {
@@ -330,26 +347,48 @@ pgconn_alloc(VALUE klass)
  *    PGconn.new(connection_hash) -> PGconn
  *    PGconn.new(connection_string) -> PGconn
  *    PGconn.new(host, port, options, tty, dbname, login, password) ->  PGconn
- *
- * * +host+ - server hostname
- * * +hostaddr+ - server address (avoids hostname lookup, overrides +host+)
- * * +port+ - server port number
- * * +dbname+ - connecting database name
- * * +user+ - login user name
- * * +password+ - login password
- * * +connect_timeout+ - maximum time to wait for connection to succeed
- * * +options+ - backend options
- * * +tty+ - (ignored in newer versions of PostgreSQL)
- * * +sslmode+ - (disable|allow|prefer|require)
- * * +krbsrvname+ - kerberos service name
- * * +gsslib+ - GSS library to use for GSSAPI authentication
- * * +service+ - service name to use for additional parameters
- *
- * _connection_hash_ example: +PGconn.connect(:dbname=>'test', :port=>5432)
- * _connection_string_ example: +PGconn.connect("dbname=test port=5432")
- * _connection_hash_ example: +PGconn.connect(nil,5432,nil,nil,'test',nil,nil)
+ * 
+ * Create a connection to the specified server.
+ * 
+ * [+host+]
+ *   server hostname
+ * [+hostaddr+]
+ *   server address (avoids hostname lookup, overrides +host+)
+ * [+port+]
+ *   server port number
+ * [+dbname+]
+ *   connecting database name
+ * [+user+]
+ *   login user name
+ * [+password+]
+ *   login password
+ * [+connect_timeout+]
+ *   maximum time to wait for connection to succeed
+ * [+options+]
+ *   backend options
+ * [+tty+]
+ *   (ignored in newer versions of PostgreSQL)
+ * [+sslmode+]
+ *   (disable|allow|prefer|require)
+ * [+krbsrvname+]
+ *   kerberos service name
+ * [+gsslib+]
+ *   GSS library to use for GSSAPI authentication
+ * [+service+]
+ *   service name to use for additional parameters
+ * 
+ * Examples:
+ * 
+ *   # As a Hash
+ *   PGconn.connect( :dbname => 'test', :port => 5432 )
+ *   
+ *   # As a String
+ *   PGconn.connect( "dbname=test port=5432" )
+ *   
+ *   # As an Array
+ *   PGconn.connect( nil, 5432, nil, nil, 'test', nil, nil )
  *  
- *  On failure, it raises a PGError exception.
+ * On failure, it raises a PGError.
  */
 static VALUE
 pgconn_init(int argc, VALUE *argv, VALUE self)
@@ -381,8 +420,8 @@ pgconn_init(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    PGconn.connect_start(connection_hash) -> PGconn
- *    PGconn.connect_start(connection_string) -> PGconn
+ *    PGconn.connect_start(connection_hash)       -> PGconn
+ *    PGconn.connect_start(connection_string)     -> PGconn
  *    PGconn.connect_start(host, port, options, tty, dbname, login, password) ->  PGconn
  *
  * This is an asynchronous version of PGconn.connect().
@@ -404,7 +443,7 @@ pgconn_s_connect_start(int argc, VALUE *argv, VALUE self)
 	rb_conn = pgconn_alloc(rb_cPGconn);
 
 	conninfo = parse_connect_args(argc, argv, self);
-	conn = PQconnectdb(StringValuePtr(conninfo));
+	conn = PQconnectStart(StringValuePtr(conninfo));
 
 	if(conn == NULL)
 		rb_raise(rb_ePGError, "PQconnectStart() unable to allocate structure");
@@ -428,13 +467,20 @@ pgconn_s_connect_start(int argc, VALUE *argv, VALUE self)
  *    PGconn.conndefaults() -> Array
  *
  * Returns an array of hashes. Each hash has the keys:
- * * +:keyword+ - the name of the option
- * * +:envvar+ - the environment variable to fall back to
- * * +:compiled+ - the compiled in option as a secondary fallback
- * * +:val+ - the option's current value, or +nil+ if not known
- * * +:label+ - the label for the field
- * * +:dispchar+ - "" for normal, "D" for debug, and "*" for password
- * * +:dispsize+ - field size
+ * [+:keyword+]
+ *   the name of the option
+ * [+:envvar+]
+ *   the environment variable to fall back to
+ * [+:compiled+]
+ *   the compiled in option as a secondary fallback
+ * [+:val+]
+ *   the option's current value, or +nil+ if not known
+ * [+:label+]
+ *   the label for the field
+ * [+:dispchar+]
+ *   "" for normal, "D" for debug, and "*" for password
+ * [+:dispsize+]
+ *   field size
  */
 static VALUE
 pgconn_s_conndefaults(VALUE self)
@@ -487,14 +533,23 @@ pgconn_s_conndefaults(VALUE self)
 static VALUE
 pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
 {
-	char *ret;
+	char *encrypted = NULL;
+	VALUE rval = Qnil;
+	
 	Check_Type(password, T_STRING);
 	Check_Type(username, T_STRING);
-	ret = PQencryptPassword(StringValuePtr(password),
-		StringValuePtr(username));
-	return rb_tainted_str_new2(ret);
+
+	encrypted = PQencryptPassword(StringValuePtr(password), StringValuePtr(username));
+	rval = rb_str_new2( encrypted );
+	PQfreemem( encrypted );
+
+	OBJ_INFECT( rval, password );
+	OBJ_INFECT( rval, username );
+
+	return rval;
 }
 
+
 /*
  * call-seq:
  *    PGconn.isthreadsafe() -> Boolean
@@ -516,10 +571,14 @@ pgconn_s_isthreadsafe(VALUE self)
  *    conn.connect_poll() -> Fixnum
  *
  * Returns one of:
- * * +PGRES_POLLING_READING+ - wait until the socket is ready to read
- * * +PGRES_POLLING_WRITING+ - wait until the socket is ready to write
- * * +PGRES_POLLING_FAILED+ - the asynchronous connection has failed
- * * +PGRES_POLLING_OK+ - the asynchronous connection is ready
+ * [+PGRES_POLLING_READING+]
+ *   wait until the socket is ready to read
+ * [+PGRES_POLLING_WRITING+]
+ *   wait until the socket is ready to write
+ * [+PGRES_POLLING_FAILED+]
+ *   the asynchronous connection has failed
+ * [+PGRES_POLLING_OK+]
+ *   the asynchronous connection is ready
  *
  * Example:
  *   conn = PGconn.connect_start("dbname=mydatabase")
@@ -768,7 +827,7 @@ pgconn_parameter_status(VALUE self, VALUE param_name)
 
 /*
  * call-seq:
- *  conn.protocol_version -> Integer
+ *   conn.protocol_version -> Integer
  *
  * The 3.0 protocol will normally be used when communicating with PostgreSQL 7.4 
  * or later servers; pre-7.4 servers support only protocol 2.0. (Protocol 1.0 is 
@@ -780,11 +839,16 @@ pgconn_protocol_version(VALUE self)
 	return INT2NUM(PQprotocolVersion(get_pgconn(self)));
 }
 
-/*
- * call-seq:
+/* 
+ * call-seq: 
  *   conn.server_version -> Integer
- *
- * The number is formed by converting the major, minor, and revision numbers into two-decimal-digit numbers and appending them together. For example, version 7.4.2 will be returned as 70402, and version 8.1 will be returned as 80100 (leading zeroes are not shown). Zero is returned if the connection is bad.
+ * 
+ * The number is formed by converting the major, minor, and revision
+ * numbers into two-decimal-digit numbers and appending them together.
+ * For example, version 7.4.2 will be returned as 70402, and version
+ * 8.1 will be returned as 80100 (leading zeroes are not shown). Zero
+ * is returned if the connection is bad.
+ * 
  */
 static VALUE
 pgconn_server_version(VALUE self)
@@ -869,6 +933,7 @@ pgconn_connection_used_password(VALUE self)
 /*
  * call-seq:
  *    conn.exec(sql [, params, result_format ] ) -> PGresult
+ *    conn.exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * Sends SQL query request specified by _sql_ to PostgreSQL.
  * Returns a PGresult instance on success.
@@ -896,6 +961,10 @@ pgconn_connection_used_password(VALUE self)
  *
  * The optional +result_format+ should be 0 for text results, 1
  * for binary.
+ *
+ * If the optional code block is given, it will be passed <i>result</i> as an argument, 
+ * and the PGresult object will  automatically be cleared when the block terminates. 
+ * In this instance, <code>conn.exec</code> returns the value of the block.
  */
 static VALUE
 pgconn_exec(int argc, VALUE *argv, VALUE self)
@@ -923,10 +992,10 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 	/* 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, 
+			return rb_ensure(rb_yield, rb_pgresult, 
 				pgresult_clear, rb_pgresult);
 		}
 		return rb_pgresult;
@@ -1007,10 +1076,10 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 	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, 
+		return rb_ensure(rb_yield, rb_pgresult, 
 			pgresult_clear, rb_pgresult);
 	}
 	return rb_pgresult;
@@ -1070,7 +1139,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 
 	xfree(paramTypes);
 
-	rb_pgresult = new_pgresult(result);
+	rb_pgresult = new_pgresult(result, conn);
 	pgresult_check(self, rb_pgresult);
 	return rb_pgresult;
 }
@@ -1078,6 +1147,7 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
 /*
  * call-seq:
  *    conn.exec_prepared(statement_name [, params, result_format ] ) -> PGresult
+ *    conn.exec_prepared(statement_name [, params, result_format ] ) {|pg_result| block }
  *
  * Execute prepared named statement specified by _statement_name_.
  * Returns a PGresult instance on success.
@@ -1098,6 +1168,10 @@ pgconn_prepare(int argc, VALUE *argv, VALUE self)
  *
  * The optional +result_format+ should be 0 for text results, 1
  * for binary.
+ *
+ * If the optional code block is given, it will be passed <i>result</i> as an argument, 
+ * and the PGresult object will  automatically be cleared when the block terminates. 
+ * In this instance, <code>conn.exec_prepared</code> returns the value of the block.
  */
 static VALUE
 pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
@@ -1189,10 +1263,10 @@ pgconn_exec_prepared(int argc, VALUE *argv, VALUE self)
 	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, 
+		return rb_ensure(rb_yield, rb_pgresult, 
 			pgresult_clear, rb_pgresult);
 	}
 	return rb_pgresult;
@@ -1220,7 +1294,7 @@ pgconn_describe_prepared(VALUE self, VALUE stmt_name)
 		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 +1322,7 @@ pgconn_describe_portal(self, stmt_name)
 		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 +1350,7 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
 	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;
 }
@@ -1297,6 +1371,8 @@ pgconn_make_empty_pgresult(VALUE self, VALUE status)
  * 
  * Consider using exec_params, which avoids the need for passing values 
  * inside of SQL commands.
+ *
+ * Encoding of escaped string will be equal to client encoding of connection.
  */
 static VALUE
 pgconn_s_escape(VALUE self, VALUE string)
@@ -1304,15 +1380,19 @@ pgconn_s_escape(VALUE self, VALUE string)
 	char *escaped;
 	int size,error;
 	VALUE result;
+#ifdef M17N_SUPPORTED	
+	rb_encoding* enc;
+#endif
 
 	Check_Type(string, T_STRING);
 
 	escaped = ALLOC_N(char, RSTRING_LEN(string) * 2 + 1);
-	if(CLASS_OF(self) == rb_cPGconn) {
+	if(rb_obj_class(self) == rb_cPGconn) {
 		size = PQescapeStringConn(get_pgconn(self), escaped, 
 			RSTRING_PTR(string), RSTRING_LEN(string), &error);
 		if(error) {
-			rb_raise(rb_ePGError, PQerrorMessage(get_pgconn(self)));
+			xfree(escaped);
+			rb_raise(rb_ePGError, "%s", PQerrorMessage(get_pgconn(self)));
 		}
 	} else {
 		size = PQescapeString(escaped, RSTRING_PTR(string),
@@ -1321,6 +1401,16 @@ pgconn_s_escape(VALUE self, VALUE string)
 	result = rb_str_new(escaped, size);
 	xfree(escaped);
 	OBJ_INFECT(result, string);
+
+#ifdef M17N_SUPPORTED
+	if(rb_obj_class(self) == rb_cPGconn) {
+		enc = pgconn_get_client_encoding_as_rb_encoding(get_pgconn(self));
+	} else {
+		enc = rb_enc_get(string);
+	}
+	rb_enc_associate(result, enc);
+#endif
+
 	return result;
 }
 
@@ -1360,7 +1450,7 @@ pgconn_s_escape_bytea(VALUE self, VALUE str)
 	from      = (unsigned char*)RSTRING_PTR(str);
 	from_len  = RSTRING_LEN(str);
 
-	if(CLASS_OF(self) == rb_cPGconn) {
+	if(rb_obj_class(self) == rb_cPGconn) {
 		to = PQescapeByteaConn(get_pgconn(self), from, from_len, &to_len);
 	} else {
 		to = PQescapeBytea( from, from_len, &to_len);
@@ -1778,6 +1868,7 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
 /*
  * call-seq:
  *    conn.get_result() -> PGresult
+ *    conn.get_result() {|pg_result| block }
  *
  * Blocks waiting for the next result from a call to
  * +PGconn#send_query+ (or another asynchronous command), and returns
@@ -1785,6 +1876,10 @@ pgconn_send_describe_portal(VALUE self, VALUE portal)
  *
  * Note: call this function repeatedly until it returns +nil+, or else
  * you will not be able to issue further commands.
+ *
+ * If the optional code block is given, it will be passed <i>result</i> as an argument, 
+ * and the PGresult object will  automatically be cleared when the block terminates. 
+ * In this instance, <code>conn.exec</code> returns the value of the block.
  */
 static VALUE
 pgconn_get_result(VALUE self)
@@ -1796,9 +1891,9 @@ pgconn_get_result(VALUE self)
 	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,
+		return rb_ensure(rb_yield, rb_pgresult,
 			pgresult_clear, rb_pgresult);
 	}
 	return rb_pgresult;
@@ -1952,11 +2047,12 @@ pgconn_cancel(VALUE self)
 	return retval;
 }
 
+
 /*
  * call-seq:
  *    conn.notifies()
  *
- * Returns an array of the unprocessed notifiers.
+ * Returns a hash of the unprocessed notifiers.
  * If there is no unprocessed notifier, it returns +nil+.
  */
 static VALUE
@@ -1991,6 +2087,68 @@ pgconn_notifies(VALUE self)
 }
 
 
+/*
+ * call-seq:
+ *    conn.wait_for_notify( [ timeout ] ) -> String
+ *    conn.wait_for_notify( [ timeout ] ) { |event, pid| block }
+ *
+ * Blocks while waiting for notification(s), or until the optional
+ * _timeout_ is reached, whichever comes first.  _timeout_ is
+ * measured in seconds and can be fractional.
+ *
+ * Returns +nil+ if _timeout_ is reached, the name of the NOTIFY
+ * event otherwise.  If used in block form, passes the name of the
+ * NOTIFY +event+ and the generating +pid+ into the block.
+ * 
+ */
+static VALUE
+pgconn_wait_for_notify(int argc, VALUE *argv, VALUE self)
+{
+    PGconn *conn = get_pgconn(self);
+    PGnotify *notify;
+    int sd = PQsocket(conn);
+    int ret;
+    struct timeval timeout;
+    struct timeval *ptimeout = NULL;
+    VALUE timeout_in, relname = Qnil, be_pid = Qnil;
+    double timeout_sec;
+    fd_set sd_rset;
+
+	if (sd < 0)
+		rb_bug("PQsocket(conn): couldn't fetch the connection's socket!");
+
+    if (rb_scan_args(argc, argv, "01", &timeout_in) == 1) {
+    	timeout_sec = NUM2DBL(timeout_in);
+    	timeout.tv_sec = (long)timeout_sec;
+    	timeout.tv_usec = (long)((timeout_sec - (long)timeout_sec) * 1e6);
+    	ptimeout = &timeout;
+    }
+
+    FD_ZERO(&sd_rset);
+    FD_SET(sd, &sd_rset);
+    ret = rb_thread_select(sd+1, &sd_rset, NULL, NULL, ptimeout);
+    if (ret == 0) {
+		return Qnil;
+	} else if (ret < 0) {
+		rb_sys_fail(0);
+	}
+	
+    if ( (ret = PQconsumeInput(conn)) != 1 ) {
+		rb_raise(rb_ePGError, "PQconsumeInput == %d: %s", ret, PQerrorMessage(conn));
+	}
+	
+    while ((notify = PQnotifies(conn)) != NULL) {
+        relname = rb_tainted_str_new2(notify->relname);
+        be_pid = INT2NUM(notify->be_pid);
+        PQfreemem(notify);
+    }
+
+    if (rb_block_given_p()) rb_yield( rb_ary_new3(2, relname, be_pid) );
+
+    return relname;
+}
+
+
 /*
  * call-seq:
  *    conn.put_copy_data( buffer ) -> Boolean
@@ -2317,18 +2475,18 @@ pgconn_transaction(VALUE self)
 	
 	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);
 		}
@@ -2346,17 +2504,18 @@ pgconn_transaction(VALUE self)
  *    PGconn.quote_ident( str ) -> String
  *    conn.quote_ident( str ) -> String
  *
- * Returns a string that is safe for inclusion in a SQL query
- * as an identifier. Note: this is not a quote function for values,
- * but for identifiers.
+ * Returns a string that is safe for inclusion in a SQL query as an
+ * identifier. Note: this is not a quote function for values, but for
+ * identifiers.
+ * 
+ * For example, in a typical SQL query: <tt>SELECT FOO FROM MYTABLE</tt>
+ * The identifier <tt>FOO</tt> is folded to lower case, so it actually
+ * means <tt>foo</tt>. If you really want to access the case-sensitive
+ * field name <tt>FOO</tt>, use this function like
+ * <tt>PGconn.quote_ident('FOO')</tt>, which will return <tt>"FOO"</tt>
+ * (with double-quotes). PostgreSQL will see the double-quotes, and
+ * it will not fold to lower case.
  * 
- * For example, in a typical SQL query: +SELECT FOO FROM MYTABLE+
- * The identifier +FOO+ is folded to lower case, so it actually means
- * +foo+. If you really want to access the case-sensitive field name
- * +FOO+, use this function like +PGconn.quote_ident('FOO')+, which
- * will return +"FOO"+ (with double-quotes). PostgreSQL will see the
- * double-quotes, and it will not fold to lower case.
- *
  * Similarly, this function also protects against special characters,
  * and other things that might allow SQL injection if the identifier
  * comes from an untrusted source.
@@ -2403,8 +2562,7 @@ pgconn_s_quote_ident(VALUE self, VALUE in_str)
  * and +conn.get_result+ will not block.
  */
 static VALUE
-pgconn_block(int argc, VALUE *argv, VALUE self)
-{
+pgconn_block( int argc, VALUE *argv, VALUE self ) {
 	PGconn *conn = get_pgconn(self);
 	int sd = PQsocket(conn);
 	int ret;
@@ -2414,27 +2572,41 @@ pgconn_block(int argc, VALUE *argv, VALUE self)
 	double timeout_sec;
 	fd_set sd_rset;
 
-	if (rb_scan_args(argc, argv, "01", &timeout_in) == 1) {
-		timeout_sec = NUM2DBL(timeout_in);
+	/* Always set a timeout in WIN32, as rb_thread_select() sometimes
+	 * doesn't return when a second ruby thread is running although data
+	 * could be read. So we use timeout-based polling instead.
+	 */
+#if defined(_WIN32)
+	timeout.tv_sec = 0;
+	timeout.tv_usec = 10000;
+	ptimeout = &timeout;
+#endif
+
+	if ( rb_scan_args(argc, argv, "01", &timeout_in) == 1 ) {
+		timeout_sec = NUM2DBL( timeout_in );
 		timeout.tv_sec = (long)timeout_sec;
 		timeout.tv_usec = (long)((timeout_sec - (long)timeout_sec) * 1e6);
 		ptimeout = &timeout;
 	}
 
-	PQconsumeInput(conn);
-	while(PQisBusy(conn)) {
-		FD_ZERO(&sd_rset);
-		FD_SET(sd, &sd_rset);
-		ret = rb_thread_select(sd+1, &sd_rset, NULL, NULL, ptimeout);
-		/* if select() times out, return false */
-		if(ret == 0) 
+	PQconsumeInput( conn );
+
+	while ( PQisBusy(conn) ) {
+		FD_ZERO( &sd_rset );
+		FD_SET( sd, &sd_rset );
+		ret = rb_thread_select( sd+1, &sd_rset, NULL, NULL, ptimeout );
+
+		/* Return false if there was a timeout argument and the select() timed out */
+		if ( ret == 0 && argc ) 
 			return Qfalse;
-		PQconsumeInput(conn);
+
+		PQconsumeInput( conn );
 	} 
 
 	return Qtrue;
 }
 
+
 /*
  * call-seq:
  *    conn.get_last_result( ) -> PGresult
@@ -2452,19 +2624,36 @@ pgconn_block(int argc, VALUE *argv, VALUE self)
 static VALUE
 pgconn_get_last_result(VALUE self)
 {
-	VALUE ret, result;
-	ret = Qnil;
-	while((result = pgconn_get_result(self)) != Qnil) {
-		ret = result;
+	PGconn *conn = get_pgconn(self);
+	VALUE rb_pgresult = Qnil;
+	PGresult *cur, *prev;
+
+
+	cur = prev = NULL;
+	while ((cur = PQgetResult(conn)) != NULL) {
+		int status;
+
+		if (prev) PQclear(prev);
+		prev = cur;
+
+		status = PQresultStatus(cur);
+		if (status == PGRES_COPY_OUT || status == PGRES_COPY_IN)
+			break;
 	}
-	pgresult_check(self, ret);
-	return ret;
+
+	if (prev) {
+		rb_pgresult = new_pgresult(prev, conn);
+		pgresult_check(self, rb_pgresult);
+	}
+
+	return rb_pgresult;
 }
 
 
 /*
  * call-seq:
  *    conn.async_exec(sql [, params, result_format ] ) -> PGresult
+ *    conn.async_exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * This function has the same behavior as +PGconn#exec+,
  * except that it's implemented using asynchronous command 
@@ -2475,11 +2664,22 @@ pgconn_get_last_result(VALUE self)
 static VALUE
 pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 {
-	pgconn_send_query(argc, argv, self);
-	pgconn_block(0, NULL, self);
-	return pgconn_get_last_result(self);
+	VALUE rb_pgresult = Qnil;
+
+	/* remove any remaining results from the queue */
+	pgconn_get_last_result( self );
+
+	pgconn_send_query( argc, argv, self );
+	pgconn_block( 0, NULL, self );
+	rb_pgresult = pgconn_get_last_result( self );
+
+	if ( rb_block_given_p() ) {
+		return rb_ensure( rb_yield, rb_pgresult, pgresult_clear, rb_pgresult );
+	}
+	return rb_pgresult;
 }
 
+
 /**************************************************************************
  * LARGE OBJECT SUPPORT
  **************************************************************************/
@@ -2551,7 +2751,7 @@ pgconn_loimport(VALUE self, VALUE filename)
 
 	lo_oid = lo_import(conn, StringValuePtr(filename));
 	if (lo_oid == 0) {
-		rb_raise(rb_ePGError, PQerrorMessage(conn));
+		rb_raise(rb_ePGError, "%s", PQerrorMessage(conn));
 	}
 	return INT2FIX(lo_oid);
 }
@@ -2575,7 +2775,7 @@ pgconn_loexport(VALUE self, VALUE lo_oid, VALUE filename)
 	}
 
 	if (lo_export(conn, oid, StringValuePtr(filename)) < 0) {
-		rb_raise(rb_ePGError, PQerrorMessage(conn));
+		rb_raise(rb_ePGError, "%s", PQerrorMessage(conn));
 	}
 	return Qnil;
 }
@@ -2606,7 +2806,7 @@ pgconn_loopen(int argc, VALUE *argv, VALUE self)
 		mode = NUM2INT(nmode);
 
 	if((fd = lo_open(conn, lo_oid, mode)) < 0) {
-		rb_raise(rb_ePGError, "can't open large object");
+		rb_raise(rb_ePGError, "can't open large object: %s", PQerrorMessage(conn));
 	}
 	return INT2FIX(fd);
 }
@@ -2632,7 +2832,7 @@ pgconn_lowrite(VALUE self, VALUE in_lo_desc, VALUE buffer)
 	}
 	if((n = lo_write(conn, fd, StringValuePtr(buffer), 
 				RSTRING_LEN(buffer))) < 0) {
-		rb_raise(rb_ePGError, "lo_write failed");
+		rb_raise(rb_ePGError, "lo_write failed: %s", PQerrorMessage(conn));
 	}
 
 	return INT2FIX(n);
@@ -2671,7 +2871,7 @@ pgconn_loread(VALUE self, VALUE in_lo_desc, VALUE in_len)
 		return Qnil;
 	}
 
-	str = rb_tainted_str_new(buffer, len);
+	str = rb_tainted_str_new(buffer, ret);
 	xfree(buffer);
 
 	return str;
@@ -2679,7 +2879,7 @@ pgconn_loread(VALUE self, VALUE in_lo_desc, VALUE in_len)
 
 
 /*
- * call-seq
+ * call-seq:
  *    conn.lo_lseek( lo_desc, offset, whence ) -> Fixnum
  *
  * Move the large object pointer _lo_desc_ to offset _offset_.
@@ -2830,7 +3030,9 @@ pgresult_result_status(VALUE self)
 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 +3044,9 @@ pgresult_res_status(VALUE self, VALUE status)
 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 +3074,9 @@ pgresult_result_error_field(VALUE self, VALUE field)
 {
 	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 +3126,7 @@ pgresult_nfields(VALUE self)
 static VALUE
 pgresult_fname(VALUE self, VALUE index)
 {
+	VALUE fname;
 	PGresult *result;
 	int i = NUM2INT(index);
 
@@ -2927,7 +3134,9 @@ pgresult_fname(VALUE self, VALUE index)
 	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;
 }
 
 /*
@@ -2966,11 +3175,14 @@ pgresult_fnumber(VALUE self, VALUE name)
 static VALUE
 pgresult_ftable(VALUE self, VALUE column_number)
 {
-	Oid n = PQftable(get_pgresult(self), NUM2INT(column_number));
-	if (n == InvalidOid) {
-		rb_raise(rb_eArgError,"Oid is undefined for column: %d", 
-			NUM2INT(column_number));
-	}
+	Oid n ;
+	int col_number = NUM2INT(column_number);
+	PGresult *pgresult = get_pgresult(self);
+
+	if( col_number < 0 || col_number >= PQnfields(pgresult)) 
+		rb_raise(rb_eArgError,"Invalid column index: %d", col_number);
+
+	n = PQftable(pgresult, col_number);
 	return INT2FIX(n);
 }
 
@@ -2987,12 +3199,15 @@ pgresult_ftable(VALUE self, VALUE column_number)
 static VALUE
 pgresult_ftablecol(VALUE self, VALUE column_number)
 {
-	int n = PQftablecol(get_pgresult(self), NUM2INT(column_number));
-	if (n == 0) {
-		rb_raise(rb_eArgError,
-			"Column number from table is undefined for column: %d", 
-			NUM2INT(column_number));
-	}
+	int col_number = NUM2INT(column_number);
+	PGresult *pgresult = get_pgresult(self);
+
+	int n;
+
+	if( col_number < 0 || col_number >= PQnfields(pgresult)) 
+		rb_raise(rb_eArgError,"Invalid column index: %d", col_number);
+	
+	n = PQftablecol(pgresult, col_number);
 	return INT2FIX(n);
 }
 
@@ -3010,7 +3225,7 @@ pgresult_fformat(VALUE self, VALUE column_number)
 {
 	PGresult *result = get_pgresult(self);
 	int fnumber = NUM2INT(column_number);
-	if (fnumber >= PQnfields(result)) {
+	if (fnumber < 0 || fnumber >= PQnfields(result)) {
 		rb_raise(rb_eArgError, "Column number is out of range: %d", 
 			fnumber);
 	}
@@ -3023,7 +3238,17 @@ pgresult_fformat(VALUE self, VALUE column_number)
  *
  * Returns the data type associated with _column_number_.
  *
- * The integer returned is the internal +OID+ number (in PostgreSQL) of the type.
+ * The integer returned is the internal +OID+ number (in PostgreSQL)
+ * of the type. To get a human-readable value for the type, use the
+ * returned OID and the field's #fmod value with the format_type() SQL 
+ * function:
+ * 
+ *   # Get the type of the second column of the result 'res'
+ *   typename = conn.
+ *     exec( "SELECT format_type($1,$2)", [res.ftype(1), res.fmod(1)] ).
+ *     getvalue( 0, 0 )
+ * 
+ * Raises an ArgumentError if _column_number_ is out of range.
  */
 static VALUE
 pgresult_ftype(VALUE self, VALUE index)
@@ -3040,9 +3265,10 @@ pgresult_ftype(VALUE self, VALUE index)
  * call-seq:
  *    res.fmod( column_number )
  *
- * Returns the type modifier associated with column _column_number_.
+ * Returns the type modifier associated with column _column_number_. See 
+ * the #ftype method for an example of how to use this.
  * 
- * Raises ArgumentError if _column_number_ is out of range.
+ * Raises an ArgumentError if _column_number_ is out of range.
  */
 static VALUE
 pgresult_fmod(VALUE self, VALUE column_number)
@@ -3050,14 +3276,12 @@ pgresult_fmod(VALUE self, VALUE column_number)
 	PGresult *result = get_pgresult(self);
 	int fnumber = NUM2INT(column_number);
 	int modifier;
-	if (fnumber >= PQnfields(result)) {
+	if (fnumber < 0 || fnumber >= PQnfields(result)) {
 		rb_raise(rb_eArgError, "Column number is out of range: %d", 
 			fnumber);
 	}
-	if((modifier = PQfmod(result,fnumber)) == -1)
-		rb_raise(rb_eArgError, 
-			"No modifier information available for column: %d", 
-			fnumber);
+	modifier = PQfmod(result,fnumber);
+
 	return INT2NUM(modifier);
 }
 
@@ -3094,6 +3318,7 @@ pgresult_fsize(VALUE self, VALUE index)
 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 +3332,10 @@ pgresult_getvalue(VALUE self, VALUE tup_num, VALUE field_num)
 	}
 	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 +3427,9 @@ pgresult_paramtype(VALUE self, VALUE param_number)
 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;
 }
 
 /*
@@ -3259,23 +3488,106 @@ pgresult_aref(VALUE self, VALUE index)
 	VALUE fname,val;
 	VALUE tuple;
 
-	if(tuple_num >= PQntuples(result))
+	if(tuple_num < 0 || tuple_num >= PQntuples(result))
 		rb_raise(rb_eIndexError, "Index %d is out of range", tuple_num);
 	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 client encoding for text format only */
+			if(0 == PQfformat(result, field_num)) { 
+				ASSOCIATE_INDEX(val, self);
+			} else {
+#ifdef M17N_SUPPORTED
+				rb_enc_associate(val, rb_ascii8bit_encoding());
+#endif
+			}
 			rb_hash_aset(tuple, fname, val);
 		}
 	}
 	return tuple;
 }
 
+
+/*
+ *  call-seq:
+ *     res.column_values( n )   -> array
+ *
+ *  Returns an Array of the values from the nth column of each 
+ *  tuple in the result.
+ *
+ */
+static VALUE
+pgresult_column_values(VALUE self, VALUE index)
+{
+	int col = NUM2INT( index );
+	return make_column_result_array( self, col );
+}
+
+
+/*
+ *  call-seq:
+ *     res.field_values( field )   -> array
+ *
+ *  Returns an Array of the values from the given _field_ of each tuple in the result.
+ *
+ */
+static VALUE
+pgresult_field_values( VALUE self, VALUE field )
+{
+	PGresult *result = get_pgresult( self );
+	const char *fieldname = RSTRING_PTR( field );
+	int fnum = PQfnumber( result, fieldname );
+
+	if ( fnum < 0 )
+		rb_raise( rb_eIndexError, "no such field '%s' in result", fieldname );
+	
+	return make_column_result_array( self, fnum );
+}
+
+
+/* 
+ * Make a Ruby array out of the encoded values from the specified
+ * column in the given result.
+ */
+static VALUE
+make_column_result_array( VALUE self, int col )
+{
+	PGresult *result = get_pgresult( self );
+	int row = PQntuples( result );
+	VALUE ary = rb_ary_new2( row );
+	VALUE val = Qnil;
+	
+	if ( col >= PQnfields(result) )
+		rb_raise( rb_eIndexError, "no column %d in result", col );
+
+	while ( row-- ) {
+		val = rb_tainted_str_new( PQgetvalue(result, row, col),
+		                          PQgetlength(result, row, col) );
+
+		/* associate client encoding for text format only */
+		if ( 0 == PQfformat(result, col) ) { 
+			ASSOCIATE_INDEX( val, self );
+		} else {
+#ifdef M17N_SUPPORTED
+			rb_enc_associate( val, rb_ascii8bit_encoding() );
+#endif
+		}
+
+		rb_ary_store( ary, row, val );
+	}
+	
+	return ary;
+}
+
+
 /*
  * call-seq:
  *    res.each{ |tuple| ... }
@@ -3311,20 +3623,287 @@ pgresult_fields(VALUE self)
 	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 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 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
-Init_pg()
+Init_pg_ext()
 {
 	rb_ePGError = rb_define_class("PGError", rb_eStandardError);
 	rb_cPGconn = rb_define_class("PGconn", rb_cObject);
 	rb_cPGresult = rb_define_class("PGresult", rb_cObject);
 
+	/* Library version */
+	rb_define_const( rb_cPGconn, "VERSION", rb_str_new2(VERSION) );
 
 	/*************************
 	 *  PGError 
@@ -3348,46 +3927,77 @@ Init_pg()
 	rb_define_singleton_method(rb_cPGconn, "escape_bytea", pgconn_s_escape_bytea, 1);
 	rb_define_singleton_method(rb_cPGconn, "unescape_bytea", pgconn_s_unescape_bytea, 1);
 	rb_define_singleton_method(rb_cPGconn, "isthreadsafe", pgconn_s_isthreadsafe, 0);
-	rb_define_singleton_method(rb_cPGconn, "encrypt_password", pgconn_s_encrypt_password, 0);
+	rb_define_singleton_method(rb_cPGconn, "encrypt_password", pgconn_s_encrypt_password, 2);
 	rb_define_singleton_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
 	rb_define_singleton_method(rb_cPGconn, "connect_start", pgconn_s_connect_start, -1);
 	rb_define_singleton_method(rb_cPGconn, "conndefaults", pgconn_s_conndefaults, 0);
 
 	/******     PGconn CLASS CONSTANTS: Connection Status     ******/
+	
+	/* Connection succeeded */
 	rb_define_const(rb_cPGconn, "CONNECTION_OK", INT2FIX(CONNECTION_OK));
+	/* Connection failed */
 	rb_define_const(rb_cPGconn, "CONNECTION_BAD", INT2FIX(CONNECTION_BAD));
 
 	/******     PGconn CLASS CONSTANTS: Nonblocking connection status     ******/
+
+	/* Waiting for connection to be made. */
 	rb_define_const(rb_cPGconn, "CONNECTION_STARTED", INT2FIX(CONNECTION_STARTED));
+	/* Connection OK; waiting to send. */
 	rb_define_const(rb_cPGconn, "CONNECTION_MADE", INT2FIX(CONNECTION_MADE));
+	/* Waiting for a response from the server. */
 	rb_define_const(rb_cPGconn, "CONNECTION_AWAITING_RESPONSE", INT2FIX(CONNECTION_AWAITING_RESPONSE));
+	/* Received authentication; waiting for backend start-up to finish. */
 	rb_define_const(rb_cPGconn, "CONNECTION_AUTH_OK", INT2FIX(CONNECTION_AUTH_OK));
+	/* Negotiating SSL encryption. */
 	rb_define_const(rb_cPGconn, "CONNECTION_SSL_STARTUP", INT2FIX(CONNECTION_SSL_STARTUP));
+	/* Negotiating environment-driven parameter settings. */
 	rb_define_const(rb_cPGconn, "CONNECTION_SETENV", INT2FIX(CONNECTION_SETENV));
 
 	/******     PGconn CLASS CONSTANTS: Nonblocking connection polling status     ******/
+
+	/* Async connection is waiting to read */
 	rb_define_const(rb_cPGconn, "PGRES_POLLING_READING", INT2FIX(PGRES_POLLING_READING));
+	/* Async connection is waiting to write */
 	rb_define_const(rb_cPGconn, "PGRES_POLLING_WRITING", INT2FIX(PGRES_POLLING_WRITING));
+	/* Async connection failed or was reset */
 	rb_define_const(rb_cPGconn, "PGRES_POLLING_FAILED", INT2FIX(PGRES_POLLING_FAILED));
+	/* Async connection succeeded */
 	rb_define_const(rb_cPGconn, "PGRES_POLLING_OK", INT2FIX(PGRES_POLLING_OK));
 
 	/******     PGconn CLASS CONSTANTS: Transaction Status     ******/
+	
+	/* Transaction is currently idle (#transaction_status) */
 	rb_define_const(rb_cPGconn, "PQTRANS_IDLE", INT2FIX(PQTRANS_IDLE));
+	/* Transaction is currently active; query has been sent to the server, but not yet completed. (#transaction_status) */
 	rb_define_const(rb_cPGconn, "PQTRANS_ACTIVE", INT2FIX(PQTRANS_ACTIVE));
+	/* Transaction is currently idle, in a valid transaction block (#transaction_status) */
 	rb_define_const(rb_cPGconn, "PQTRANS_INTRANS", INT2FIX(PQTRANS_INTRANS));
+	/* Transaction is currently idle, in a failed transaction block (#transaction_status) */
 	rb_define_const(rb_cPGconn, "PQTRANS_INERROR", INT2FIX(PQTRANS_INERROR));
+	/* Transaction's connection is bad (#transaction_status) */
 	rb_define_const(rb_cPGconn, "PQTRANS_UNKNOWN", INT2FIX(PQTRANS_UNKNOWN));
 
 	/******     PGconn CLASS CONSTANTS: Error Verbosity     ******/
+
+	/* Terse error verbosity level (#set_error_verbosity) */
 	rb_define_const(rb_cPGconn, "PQERRORS_TERSE", INT2FIX(PQERRORS_TERSE));
+	/* Default error verbosity level (#set_error_verbosity) */
 	rb_define_const(rb_cPGconn, "PQERRORS_DEFAULT", INT2FIX(PQERRORS_DEFAULT));
+	/* Verbose error verbosity level (#set_error_verbosity) */
 	rb_define_const(rb_cPGconn, "PQERRORS_VERBOSE", INT2FIX(PQERRORS_VERBOSE));
 
 	/******     PGconn CLASS CONSTANTS: Large Objects     ******/
+
+	/* Flag for #lo_creat, #lo_open -- open for writing */
 	rb_define_const(rb_cPGconn, "INV_WRITE", INT2FIX(INV_WRITE));
+	/* Flag for #lo_creat, #lo_open -- open for reading */
 	rb_define_const(rb_cPGconn, "INV_READ", INT2FIX(INV_READ));
+	/* Flag for #lo_lseek -- seek from object start */
 	rb_define_const(rb_cPGconn, "SEEK_SET", INT2FIX(SEEK_SET));
+	/* Flag for #lo_lseek -- seek from current position */
 	rb_define_const(rb_cPGconn, "SEEK_CUR", INT2FIX(SEEK_CUR));
+	/* Flag for #lo_lseek -- seek from object end */
 	rb_define_const(rb_cPGconn, "SEEK_END", INT2FIX(SEEK_END));
 
 	/******     PGconn INSTANCE METHODS: Connection Control     ******/
@@ -3444,6 +4054,7 @@ Init_pg()
 	rb_define_method(rb_cPGconn, "is_busy", pgconn_is_busy, 0);
 	rb_define_method(rb_cPGconn, "setnonblocking", pgconn_setnonblocking, 1);
 	rb_define_method(rb_cPGconn, "isnonblocking", pgconn_isnonblocking, 0);
+	rb_define_alias(rb_cPGconn, "nonblocking?", "isnonblocking");
 	rb_define_method(rb_cPGconn, "flush", pgconn_flush, 0);
 
 	/******     PGconn INSTANCE METHODS: Cancelling Queries in Progress     ******/
@@ -3471,6 +4082,8 @@ Init_pg()
 	rb_define_method(rb_cPGconn, "set_client_encoding", pgconn_set_client_encoding, 1);
 	rb_define_method(rb_cPGconn, "transaction", pgconn_transaction, 0);
 	rb_define_method(rb_cPGconn, "block", pgconn_block, -1);
+	rb_define_method(rb_cPGconn, "wait_for_notify", pgconn_wait_for_notify, -1);
+	rb_define_alias(rb_cPGconn, "notifies_wait", "wait_for_notify");
 	rb_define_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
 	rb_define_method(rb_cPGconn, "async_exec", pgconn_async_exec, -1);
 	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
@@ -3510,29 +4123,92 @@ Init_pg()
 	rb_include_module(rb_cPGresult, rb_mEnumerable);
 
 	/******     PGresult CONSTANTS: result status      ******/
+
+	/* #result_status constant: The string sent to the server was empty. */
 	rb_define_const(rb_cPGresult, "PGRES_EMPTY_QUERY", INT2FIX(PGRES_EMPTY_QUERY));
+	/* #result_status constant: Successful completion of a command returning no data. */
 	rb_define_const(rb_cPGresult, "PGRES_COMMAND_OK", INT2FIX(PGRES_COMMAND_OK));
+ 	/* #result_status constant: Successful completion of a command returning data 
+	   (such as a SELECT or SHOW). */
 	rb_define_const(rb_cPGresult, "PGRES_TUPLES_OK", INT2FIX(PGRES_TUPLES_OK));
+	/* #result_status constant: Copy Out (from server) data transfer started. */
 	rb_define_const(rb_cPGresult, "PGRES_COPY_OUT", INT2FIX(PGRES_COPY_OUT));
+	/* #result_status constant: Copy In (to server) data transfer started. */
 	rb_define_const(rb_cPGresult, "PGRES_COPY_IN", INT2FIX(PGRES_COPY_IN));
+	/* #result_status constant: The server’s response was not understood. */
 	rb_define_const(rb_cPGresult, "PGRES_BAD_RESPONSE", INT2FIX(PGRES_BAD_RESPONSE));
+	/* #result_status constant: A nonfatal error (a notice or warning) occurred. */
 	rb_define_const(rb_cPGresult, "PGRES_NONFATAL_ERROR",INT2FIX(PGRES_NONFATAL_ERROR));
+	/* #result_status constant: A fatal error occurred. */
 	rb_define_const(rb_cPGresult, "PGRES_FATAL_ERROR", INT2FIX(PGRES_FATAL_ERROR));
 
 	/******     PGresult CONSTANTS: result error field codes      ******/
+
+	/* #result_error_field argument constant: The severity; the field contents
+	 * are ERROR, FATAL, or PANIC (in an error message), or WARNING, NOTICE,
+	 * DEBUG, INFO, or LOG (in a notice message), or a localized translation
+	 * of one of these. Always present.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_SEVERITY", INT2FIX(PG_DIAG_SEVERITY));
+	/* #result_error_field argument constant: The SQLSTATE code for the
+	 * error. The SQLSTATE code identies the type of error that has occurred;
+	 * it can be used by front-end applications to perform specic operations
+	 * (such as er- ror handling) in response to a particular database
+	 * error. For a list of the possible SQLSTATE codes, see Appendix A.
+	 * This eld is not localizable, and is always present.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_SQLSTATE", INT2FIX(PG_DIAG_SQLSTATE));
+	/* #result_error_field argument constant: The primary human-readable
+	 * error message (typically one line). Always present. */
 	rb_define_const(rb_cPGresult, "PG_DIAG_MESSAGE_PRIMARY", INT2FIX(PG_DIAG_MESSAGE_PRIMARY));
+	/* #result_error_field argument constant: Detail: an optional secondary
+	 * error message carrying more detail about the problem. Might run to
+	 * multiple lines.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_MESSAGE_DETAIL", INT2FIX(PG_DIAG_MESSAGE_DETAIL));
+	/* #result_error_field argument constant: Hint: an optional suggestion
+	 * what to do about the problem. This is intended to differ from detail
+	 * in that it offers advice (potentially inappropriate) rather than
+	 * hard facts. Might run to multiple lines.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_MESSAGE_HINT", INT2FIX(PG_DIAG_MESSAGE_HINT));
+	/* #result_error_field argument constant: A string containing a decimal
+	 * integer indicating an error cursor position as an index into the
+	 * original statement string. The rst character has index 1, and
+	 * positions are measured in characters not bytes.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_STATEMENT_POSITION", INT2FIX(PG_DIAG_STATEMENT_POSITION));
+	/* #result_error_field argument constant: This is dened the same as
+	 * the PG_DIAG_STATEMENT_POSITION eld, but it is used when the cursor
+	 * position refers to an internally generated command rather than the
+	 * one submitted by the client. The PG_DIAG_INTERNAL_QUERY eld will
+	 * always appear when this eld appears.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_INTERNAL_POSITION", INT2FIX(PG_DIAG_INTERNAL_POSITION));
+	/* #result_error_field argument constant: The text of a failed
+	 * internally-generated command. This could be, for example, a SQL
+	 * query issued by a PL/pgSQL function.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_INTERNAL_QUERY", INT2FIX(PG_DIAG_INTERNAL_QUERY));
+	/* #result_error_field argument constant: An indication of the context
+	 * in which the error occurred. Presently this includes a call stack
+	 * traceback of active procedural language functions and internally-generated
+	 * queries. The trace is one entry per line, most recent rst.
+	 */
 	rb_define_const(rb_cPGresult, "PG_DIAG_CONTEXT", INT2FIX(PG_DIAG_CONTEXT));
+	/* #result_error_field argument constant: The le name of the source-code
+	 * location where the error was reported. */
 	rb_define_const(rb_cPGresult, "PG_DIAG_SOURCE_FILE", INT2FIX(PG_DIAG_SOURCE_FILE));
+	/* #result_error_field argument constant: The line number of the
+	 * source-code location where the error was reported. */
 	rb_define_const(rb_cPGresult, "PG_DIAG_SOURCE_LINE", INT2FIX(PG_DIAG_SOURCE_LINE));
+	/* #result_error_field argument constant: The name of the source-code
+	 * function reporting the error. */
 	rb_define_const(rb_cPGresult, "PG_DIAG_SOURCE_FUNCTION", INT2FIX(PG_DIAG_SOURCE_FUNCTION));
 
+	/* Invalid OID constant */
+	rb_define_const(rb_cPGresult, "InvalidOid", INT2FIX(InvalidOid));
+
 	/******     PGresult 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);
@@ -3555,7 +4231,7 @@ Init_pg()
 	rb_define_method(rb_cPGresult, "getisnull", pgresult_getisnull, 2);
 	rb_define_method(rb_cPGresult, "getlength", pgresult_getlength, 2);
 	rb_define_method(rb_cPGresult, "nparams", pgresult_nparams, 0);
-	rb_define_method(rb_cPGresult, "paramtype", pgresult_paramtype, 0);
+	rb_define_method(rb_cPGresult, "paramtype", pgresult_paramtype, 1);
 	rb_define_method(rb_cPGresult, "cmd_status", pgresult_cmd_status, 0);
 	rb_define_method(rb_cPGresult, "cmd_tuples", pgresult_cmd_tuples, 0);
 	rb_define_alias(rb_cPGresult, "cmdtuples", "cmd_tuples");
@@ -3565,5 +4241,10 @@ Init_pg()
 	rb_define_method(rb_cPGresult, "[]", pgresult_aref, 1);
 	rb_define_method(rb_cPGresult, "each", pgresult_each, 0);
 	rb_define_method(rb_cPGresult, "fields", pgresult_fields, 0);
+	rb_define_method(rb_cPGresult, "column_values", pgresult_column_values, 1);
+	rb_define_method(rb_cPGresult, "field_values", pgresult_field_values, 1);
 
+#ifdef M17N_SUPPORTED
+	init_m17n();
+#endif
 }