pg 1.1.4

data/ext/extconf.rb

@@ -0,0 +1,94 @@
+require 'pp'
+require 'mkmf'
+
+
+if ENV['MAINTAINER_MODE']
+	$stderr.puts "Maintainer mode enabled."
+	$CFLAGS <<
+		' -Wall' <<
+		' -ggdb' <<
+		' -DDEBUG' <<
+		' -pedantic'
+end
+
+if pgdir = with_config( 'pg' )
+	ENV['PATH'] = "#{pgdir}/bin" + File::PATH_SEPARATOR + ENV['PATH']
+end
+
+if enable_config("windows-cross")
+	# Avoid dependency to external libgcc.dll on x86-mingw32
+	$LDFLAGS << " -static-libgcc"
+	# Don't use pg_config for cross build, but --with-pg-* path options
+	dir_config 'pg'
+
+else
+	# Native build
+
+	pgconfig = with_config('pg-config') ||
+		with_config('pg_config') ||
+		find_executable('pg_config')
+
+	if pgconfig && pgconfig != 'ignore'
+		$stderr.puts "Using config values from %s" % [ pgconfig ]
+		incdir = `"#{pgconfig}" --includedir`.chomp
+		libdir = `"#{pgconfig}" --libdir`.chomp
+		dir_config 'pg', incdir, libdir
+
+		# Try to use runtime path linker option, even if RbConfig doesn't know about it.
+		# The rpath option is usually set implicit by dir_config(), but so far not
+		# on MacOS-X.
+		if RbConfig::CONFIG["RPATHFLAG"].to_s.empty? && try_link('int main() {return 0;}', " -Wl,-rpath,#{libdir}")
+			$LDFLAGS << " -Wl,-rpath,#{libdir}"
+		end
+	else
+		$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
+			" --with-pg-config=/path/to/pg_config"
+		dir_config 'pg'
+	end
+end
+
+if RUBY_VERSION >= '2.3.0' && /solaris/ =~ RUBY_PLATFORM
+	append_cppflags( '-D__EXTENSIONS__' )
+end
+
+find_header( 'libpq-fe.h' ) or abort "Can't find the 'libpq-fe.h header"
+find_header( 'libpq/libpq-fs.h' ) or abort "Can't find the 'libpq/libpq-fs.h header"
+find_header( 'pg_config_manual.h' ) or abort "Can't find the 'pg_config_manual.h' header"
+
+abort "Can't find the PostgreSQL client library (libpq)" unless
+	have_library( 'pq', 'PQconnectdb', ['libpq-fe.h'] ) ||
+	have_library( 'libpq', 'PQconnectdb', ['libpq-fe.h'] ) ||
+	have_library( 'ms/libpq', 'PQconnectdb', ['libpq-fe.h'] )
+
+if /mingw/ =~ RUBY_PLATFORM && RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
+	# Work around: https://sourceware.org/bugzilla/show_bug.cgi?id=22504
+	checking_for "workaround gcc version with link issue" do
+		`#{RbConfig::MAKEFILE_CONFIG['CC']} --version`.chomp =~ /\s(\d+)\.\d+\.\d+(\s|$)/ &&
+			$1.to_i >= 6 &&
+			have_library(':libpq.lib') # Prefer linking to libpq.lib over libpq.dll if available
+	end
+end
+
+# optional headers/functions
+have_func 'PQsetSingleRowMode' or
+	abort "Your PostgreSQL is too old. Either install an older version " +
+	      "of this gem or upgrade your database to at least PostgreSQL-9.2."
+have_func 'PQconninfo'
+have_func 'PQsslAttribute'
+have_func 'PQencryptPasswordConn'
+have_func 'timegm'
+have_func 'rb_gc_adjust_memory_usage'
+
+have_const 'PG_DIAG_TABLE_NAME', 'libpq-fe.h'
+
+# unistd.h confilicts with ruby/win32.h when cross compiling for win32 and ruby 1.9.1
+have_header 'unistd.h'
+have_header 'inttypes.h'
+
+checking_for "C99 variable length arrays" do
+	$defs.push( "-DHAVE_VARIABLE_LENGTH_ARRAYS" ) if try_compile('void test_vla(int l){ int vla[l]; }')
+end
+
+create_header()
+create_makefile( "pg_ext" )
+

data/ext/gvl_wrappers.c

@@ -0,0 +1,17 @@
+/*
+ * gvl_wrappers.c - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ */
+
+#include "pg.h"
+
+#ifndef HAVE_PQENCRYPTPASSWORDCONN
+char *PQencryptPasswordConn(PGconn *conn, const char *passwd, const char *user, const char *algorithm){return NULL;}
+#endif
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_SKELETON );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_SKELETON );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_STUB );

data/ext/gvl_wrappers.h

@@ -0,0 +1,241 @@
+/*
+ * gvl_wrappers.h - Wrapper functions for locking/unlocking the Ruby GVL
+ *
+ * These are some obscure preprocessor directives that allow to generate
+ * drop-in replacement wrapper functions in a declarative manner.
+ * These wrapper functions ensure that ruby's GVL is released on each
+ * function call and reacquired at the end of the call or in callbacks.
+ * This way blocking functions calls don't block concurrent ruby threads.
+ *
+ * The wrapper of each function is prefixed by "gvl_".
+ *
+ * Use "gcc -E" to retrieve the generated code.
+ */
+
+#ifndef __gvl_wrappers_h
+#define __gvl_wrappers_h
+
+#include <ruby/thread.h>
+
+#define DEFINE_PARAM_LIST1(type, name) \
+	name,
+
+#define DEFINE_PARAM_LIST2(type, name) \
+	p->params.name,
+
+#define DEFINE_PARAM_LIST3(type, name) \
+	type name,
+
+#define DEFINE_PARAM_DECL(type, name) \
+	type name;
+
+#define DEFINE_GVL_WRAPPER_STRUCT(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	struct gvl_wrapper_##name##_params { \
+		struct { \
+			FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_DECL) \
+			lastparamtype lastparamname; \
+		} params; \
+		when_non_void( rettype retval; ) \
+	};
+
+#define DEFINE_GVL_SKELETON(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	static void * gvl_##name##_skeleton( void *data ){ \
+		struct gvl_wrapper_##name##_params *p = (struct gvl_wrapper_##name##_params*)data; \
+		when_non_void( p->retval = ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST2) p->params.lastparamname ); \
+		return NULL; \
+	}
+
+#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+		struct gvl_wrapper_##name##_params params = { \
+			{FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname}, when_non_void((rettype)0) \
+		}; \
+		rb_thread_call_without_gvl(gvl_##name##_skeleton, &params, RUBY_UBF_IO, 0); \
+		when_non_void( return params.retval; ) \
+	}
+
+#define DEFINE_GVL_STUB_DECL(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname);
+
+#define DEFINE_GVLCB_SKELETON(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	static void * gvl_##name##_skeleton( void *data ){ \
+		struct gvl_wrapper_##name##_params *p = (struct gvl_wrapper_##name##_params*)data; \
+		when_non_void( p->retval = ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST2) p->params.lastparamname ); \
+		return NULL; \
+	}
+
+#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+		struct gvl_wrapper_##name##_params params = { \
+			{FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname}, when_non_void((rettype)0) \
+		}; \
+		rb_thread_call_with_gvl(gvl_##name##_skeleton, &params); \
+		when_non_void( return params.retval; ) \
+	}
+
+#define GVL_TYPE_VOID(string)
+#define GVL_TYPE_NONVOID(string) string
+
+
+/*
+ * Definitions of blocking functions and their parameters
+ */
+
+#define FOR_EACH_PARAM_OF_PQconnectdb(param)
+
+#define FOR_EACH_PARAM_OF_PQconnectStart(param)
+
+#define FOR_EACH_PARAM_OF_PQconnectPoll(param)
+
+#define FOR_EACH_PARAM_OF_PQreset(param)
+
+#define FOR_EACH_PARAM_OF_PQresetStart(param)
+
+#define FOR_EACH_PARAM_OF_PQresetPoll(param)
+
+#define FOR_EACH_PARAM_OF_PQexec(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQexecParams(param) \
+	param(PGconn *, conn) \
+	param(const char *, command) \
+	param(int, nParams) \
+	param(const Oid *, paramTypes) \
+	param(const char * const *, paramValues) \
+	param(const int *, paramLengths) \
+	param(const int *, paramFormats)
+
+#define FOR_EACH_PARAM_OF_PQexecPrepared(param) \
+	param(PGconn *, conn) \
+	param(const char *, stmtName) \
+	param(int, nParams) \
+	param(const char * const *, paramValues) \
+	param(const int *, paramLengths) \
+	param(const int *, paramFormats)
+
+#define FOR_EACH_PARAM_OF_PQprepare(param) \
+	param(PGconn *, conn) \
+	param(const char *, stmtName) \
+	param(const char *, query) \
+	param(int, nParams)
+
+#define FOR_EACH_PARAM_OF_PQdescribePrepared(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQdescribePortal(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQgetResult(param)
+
+#define FOR_EACH_PARAM_OF_PQputCopyData(param) \
+	param(PGconn *, conn) \
+	param(const char *, buffer)
+
+#define FOR_EACH_PARAM_OF_PQputCopyEnd(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQgetCopyData(param) \
+	param(PGconn *, conn) \
+	param(char **, buffer)
+
+#define FOR_EACH_PARAM_OF_PQnotifies(param)
+
+#define FOR_EACH_PARAM_OF_PQsendQuery(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQsendQueryParams(param) \
+	param(PGconn *, conn) \
+	param(const char *, command) \
+	param(int, nParams) \
+	param(const Oid *, paramTypes) \
+	param(const char *const *, paramValues) \
+	param(const int *, paramLengths) \
+	param(const int *, paramFormats)
+
+#define FOR_EACH_PARAM_OF_PQsendPrepare(param) \
+	param(PGconn *, conn) \
+	param(const char *, stmtName) \
+	param(const char *, query) \
+	param(int, nParams)
+
+#define FOR_EACH_PARAM_OF_PQsendQueryPrepared(param) \
+	param(PGconn *, conn) \
+	param(const char *, stmtName) \
+	param(int, nParams) \
+	param(const char *const *, paramValues) \
+	param(const int *, paramLengths) \
+	param(const int *, paramFormats)
+
+#define FOR_EACH_PARAM_OF_PQsendDescribePrepared(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQsendDescribePortal(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQsetClientEncoding(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQisBusy(param)
+
+#define FOR_EACH_PARAM_OF_PQencryptPasswordConn(param) \
+	param(PGconn *, conn) \
+	param(const char *, passwd) \
+	param(const char *, user)
+
+#define FOR_EACH_PARAM_OF_PQcancel(param) \
+	param(PGcancel *, cancel) \
+	param(char *, errbuf)
+
+/* function( name, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
+#define FOR_EACH_BLOCKING_FUNCTION(function) \
+	function(PQconnectdb, GVL_TYPE_NONVOID, PGconn *, const char *, conninfo) \
+	function(PQconnectStart, GVL_TYPE_NONVOID, PGconn *, const char *, conninfo) \
+	function(PQconnectPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	function(PQreset, GVL_TYPE_VOID, void, PGconn *, conn) \
+	function(PQresetStart, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQresetPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	function(PQexec, GVL_TYPE_NONVOID, PGresult *, const char *, command) \
+	function(PQexecParams, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
+	function(PQexecPrepared, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
+	function(PQprepare, GVL_TYPE_NONVOID, PGresult *, const Oid *, paramTypes) \
+	function(PQdescribePrepared, GVL_TYPE_NONVOID, PGresult *, const char *, stmtName) \
+	function(PQdescribePortal, GVL_TYPE_NONVOID, PGresult *, const char *, portalName) \
+	function(PQgetResult, GVL_TYPE_NONVOID, PGresult *, PGconn *, conn) \
+	function(PQputCopyData, GVL_TYPE_NONVOID, int, int, nbytes) \
+	function(PQputCopyEnd, GVL_TYPE_NONVOID, int, const char *, errormsg) \
+	function(PQgetCopyData, GVL_TYPE_NONVOID, int, int, async) \
+	function(PQnotifies, GVL_TYPE_NONVOID, PGnotify *, PGconn *, conn) \
+	function(PQsendQuery, GVL_TYPE_NONVOID, int, const char *, query) \
+	function(PQsendQueryParams, GVL_TYPE_NONVOID, int, int, resultFormat) \
+	function(PQsendPrepare, GVL_TYPE_NONVOID, int, const Oid *, paramTypes) \
+	function(PQsendQueryPrepared, GVL_TYPE_NONVOID, int, int, resultFormat) \
+	function(PQsendDescribePrepared, GVL_TYPE_NONVOID, int, const char *, stmt) \
+	function(PQsendDescribePortal, GVL_TYPE_NONVOID, int, const char *, portal) \
+	function(PQsetClientEncoding, GVL_TYPE_NONVOID, int, const char *, encoding) \
+	function(PQisBusy, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQencryptPasswordConn, GVL_TYPE_NONVOID, char *, const char *, algorithm) \
+	function(PQcancel, GVL_TYPE_NONVOID, int, int, errbufsize);
+
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
+
+
+/*
+ * Definitions of callback functions and their parameters
+ */
+
+#define FOR_EACH_PARAM_OF_notice_processor_proxy(param) \
+	param(void *, arg)
+
+#define FOR_EACH_PARAM_OF_notice_receiver_proxy(param) \
+	param(void *, arg)
+
+/* function( name, void_or_nonvoid, returntype, lastparamtype, lastparamname ) */
+#define FOR_EACH_CALLBACK_FUNCTION(function) \
+	function(notice_processor_proxy, GVL_TYPE_VOID, void, const char *, message) \
+	function(notice_receiver_proxy, GVL_TYPE_VOID, void, const PGresult *, result) \
+
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVL_STUB_DECL );
+
+#endif /* end __gvl_wrappers_h */

data/ext/pg.c

@@ -0,0 +1,640 @@
+/*
+ * pg.c - Toplevel extension
+ * $Id: pg.c,v 2d334508484a 2018/08/27 11:33:43 lars $
+ *
+ * Author/s:
+ *
+ * - Jeff Davis <ruby-pg@j-davis.com>
+ * - Guy Decoux (ts) <decoux@moulon.inra.fr>
+ * - Michael Granger <ged@FaerieMUD.org>
+ * - Lars Kanis <lars@greiz-reinsdorf.de>
+ * - Dave Lee
+ * - Eiji Matsumoto <usagi@ruby.club.or.jp>
+ * - Yukihiro Matsumoto <matz@ruby-lang.org>
+ * - Noboru Saitou <noborus@netlab.jp>
+ *
+ * See Contributors.rdoc for the many additional fine people that have contributed
+ * to this library over the years.
+ *
+ * Copyright (c) 1997-2016 by the authors.
+ *
+ * You may redistribute this software under the same terms as Ruby itself; see
+ * https://www.ruby-lang.org/en/about/license.txt or the BSDL file in the source
+ * for details.
+ *
+ * Portions of the code are from the PostgreSQL project, and are distributed
+ * under the terms of the PostgreSQL license, included in the file "POSTGRES".
+ *
+ * Portions copyright LAIKA, Inc.
+ *
+ *
+ * The following functions are part of libpq, but not available from ruby-pg,
+ * because they are deprecated, obsolete, or generally not useful:
+ *
+ * - PQfreemem -- unnecessary: copied to ruby object, then freed. Ruby object's
+ *                memory is freed when it is garbage collected.
+ * - PQbinaryTuples -- better to use PQfformat
+ * - PQprint -- not very useful
+ * - PQsetdb -- not very useful
+ * - PQoidStatus -- deprecated, use PQoidValue
+ * - PQrequestCancel -- deprecated, use PQcancel
+ * - PQfn -- use a prepared statement instead
+ * - PQgetline -- deprecated, use PQgetCopyData
+ * - PQgetlineAsync -- deprecated, use PQgetCopyData
+ * - PQputline -- deprecated, use PQputCopyData
+ * - PQputnbytes -- deprecated, use PQputCopyData
+ * - PQendcopy -- deprecated, use PQputCopyEnd
+ */
+
+#include "pg.h"
+
+int pg_skip_deprecation_warning;
+VALUE rb_mPG;
+VALUE rb_mPGconstants;
+
+
+/*
+ * Document-class: PG::Error
+ *
+ * This is the exception class raised when an error is returned from
+ * a libpq API call.
+ *
+ * The attributes +connection+ and +result+ are set to the connection
+ * object and result set object, respectively.
+ *
+ * If the connection object or result set object is not available from
+ * the context in which the error was encountered, it is +nil+.
+ */
+
+/*
+ * M17n functions
+ */
+
+/**
+ * The mapping from canonical encoding names in PostgreSQL to ones in Ruby.
+ */
+const char * const (pg_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-R"      },
+	{"KOI8R",         "KOI8-R"      },
+	{"KOI8U",         "KOI8-U"      },
+	{"LATIN1",        "ISO-8859-1"  },
+	{"LATIN2",        "ISO-8859-2"  },
+	{"LATIN3",        "ISO-8859-3"  },
+	{"LATIN4",        "ISO-8859-4"  },
+	{"LATIN5",        "ISO-8859-9"  },
+	{"LATIN6",        "ISO-8859-10" },
+	{"LATIN7",        "ISO-8859-13" },
+	{"LATIN8",        "ISO-8859-14" },
+	{"LATIN9",        "ISO-8859-15" },
+	{"LATIN10",       "ISO-8859-16" },
+	{"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;
+
+
+/*
+ * Look up the JOHAB encoding, creating it as a dummy encoding if it's not
+ * already defined.
+ */
+static rb_encoding *
+pg_find_or_create_johab(void)
+{
+	static const char * const aliases[] = { "JOHAB", "Windows-1361", "CP1361" };
+	int enc_index;
+	size_t 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]);
+	return rb_enc_from_index(enc_index);
+}
+
+/*
+ * Return the given PostgreSQL encoding ID as an rb_encoding.
+ *
+ * - returns NULL if the client encoding is 'SQL_ASCII'.
+ * - returns ASCII-8BIT if the client encoding is unknown.
+ */
+rb_encoding *
+pg_get_pg_encoding_as_rb_encoding( int enc_id )
+{
+	rb_encoding *enc;
+
+	/* Use the cached value if it exists */
+	if ( st_lookup(enc_pg2ruby, (st_data_t)enc_id, (st_data_t*)&enc) ) {
+		return enc;
+	}
+	else {
+		const char *name = pg_encoding_to_char( enc_id );
+
+		enc = pg_get_pg_encname_as_rb_encoding( name );
+		st_insert( enc_pg2ruby, (st_data_t)enc_id, (st_data_t)enc );
+
+		return enc;
+	}
+
+}
+
+/*
+ * Return the given PostgreSQL encoding name as an rb_encoding.
+ */
+rb_encoding *
+pg_get_pg_encname_as_rb_encoding( const char *pg_encname )
+{
+	size_t i;
+
+	/* Trying looking it up in the conversion table */
+	for ( i = 0; i < sizeof(pg_enc_pg2ruby_mapping)/sizeof(pg_enc_pg2ruby_mapping[0]); ++i ) {
+		if ( strcmp(pg_encname, pg_enc_pg2ruby_mapping[i][0]) == 0 )
+			return rb_enc_find( pg_enc_pg2ruby_mapping[i][1] );
+	}
+
+	/* JOHAB isn't a builtin encoding, so make up a dummy encoding if it's seen */
+	if ( strncmp(pg_encname, "JOHAB", 5) == 0 )
+		return pg_find_or_create_johab();
+
+	/* Fallthrough to ASCII-8BIT */
+	return rb_ascii8bit_encoding();
+}
+
+/*
+ * Get the client encoding of the specified connection handle and return it as a rb_encoding.
+ */
+rb_encoding *
+pg_conn_enc_get( PGconn *conn )
+{
+	int enc_id = PQclientEncoding( conn );
+	return pg_get_pg_encoding_as_rb_encoding( enc_id );
+}
+
+
+/*
+ * Returns the given rb_encoding as the equivalent PostgreSQL encoding string.
+ */
+const char *
+pg_get_rb_encoding_as_pg_encoding( rb_encoding *enc )
+{
+	const char *rb_encname = rb_enc_name( enc );
+	const char *encname = NULL;
+	size_t i;
+
+	for (i = 0; i < sizeof(pg_enc_pg2ruby_mapping)/sizeof(pg_enc_pg2ruby_mapping[0]); ++i) {
+		if (strcmp(rb_encname, pg_enc_pg2ruby_mapping[i][1]) == 0) {
+			encname = pg_enc_pg2ruby_mapping[i][0];
+		}
+	}
+
+	if ( !encname ) encname = "SQL_ASCII";
+
+	return encname;
+}
+
+
+/*
+ * Ensures that the given string has enough capacity to take expand_len
+ * more data bytes. The new data part of the String is not initialized.
+ *
+ * current_out must be a pointer within the data part of the String object.
+ * This pointer is returned and possibly adjusted, because the location of the data
+ * part of the String can change through this function.
+ *
+ * PG_RB_STR_ENSURE_CAPA can be used to do fast inline checks of the remaining capacity.
+ * end_capa it is then set to the first byte after the currently reserved memory,
+ * if not NULL.
+ *
+ * Before the String can be used with other string functions or returned to Ruby space,
+ * the string length has to be set with rb_str_set_len().
+ *
+ * Usage example:
+ *
+ *   VALUE string;
+ *   char *current_out, *end_capa;
+ *   PG_RB_STR_NEW( string, current_out, end_capa );
+ *   while( data_is_going_to_be_processed ){
+ *     PG_RB_STR_ENSURE_CAPA( string, 2, current_out, end_capa );
+ *     *current_out++ = databyte1;
+ *     *current_out++ = databyte2;
+ *   }
+ *   rb_str_set_len( string, current_out - RSTRING_PTR(string) );
+ *
+ */
+char *
+pg_rb_str_ensure_capa( VALUE str, long expand_len, char *curr_ptr, char **end_ptr )
+{
+	long curr_len = curr_ptr - RSTRING_PTR(str);
+	long curr_capa = rb_str_capacity( str );
+	if( curr_capa < curr_len + expand_len ){
+		rb_str_set_len( str, curr_len );
+		rb_str_modify_expand( str, (curr_len + expand_len) * 2 - curr_capa );
+		curr_ptr = RSTRING_PTR(str) + curr_len;
+	}
+	if( end_ptr )
+		*end_ptr = RSTRING_PTR(str) + rb_str_capacity( str );
+	return curr_ptr;
+}
+
+
+/**************************************************************************
+ * Module Methods
+ **************************************************************************/
+
+/*
+ * call-seq:
+ *   PG.library_version -> Integer
+ *
+ * Get the version of the libpq library in use. 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
+pg_s_library_version(VALUE self)
+{
+	UNUSED( self );
+	return INT2NUM(PQlibVersion());
+}
+
+
+/*
+ * call-seq:
+ *    PG.isthreadsafe            -> Boolean
+ *    PG.is_threadsafe?          -> Boolean
+ *    PG.threadsafe?             -> Boolean
+ *
+ * Returns +true+ if libpq is thread-safe, +false+ otherwise.
+ */
+static VALUE
+pg_s_threadsafe_p(VALUE self)
+{
+	UNUSED( self );
+	return PQisthreadsafe() ? Qtrue : Qfalse;
+}
+
+static int
+pg_to_bool_int(VALUE value)
+{
+	switch( TYPE(value) ){
+		case T_FALSE:
+			return 0;
+		case T_TRUE:
+			return 1;
+		default:
+			return NUM2INT(value);
+	}
+}
+
+/*
+ * call-seq:
+ *    PG.init_openssl(do_ssl, do_crypto)  -> nil
+ *
+ * Allows applications to select which security libraries to initialize.
+ *
+ * If your application initializes libssl and/or libcrypto libraries and libpq is
+ * built with SSL support, you should call PG.init_openssl() to tell libpq that the
+ * libssl and/or libcrypto libraries have been initialized by your application,
+ * so that libpq will not also initialize those libraries. See
+ * http://h71000.www7.hp.com/doc/83final/BA554_90007/ch04.html for details on the SSL API.
+ *
+ * When do_ssl is +true+, libpq will initialize the OpenSSL library before first
+ * opening a database connection. When do_crypto is +true+, the libcrypto library
+ * will be initialized. By default (if PG.init_openssl() is not called), both libraries
+ * are initialized. When SSL support is not compiled in, this function is present but does nothing.
+ *
+ * If your application uses and initializes either OpenSSL or its underlying libcrypto library,
+ * you must call this function with +false+ for the appropriate parameter(s) before first opening
+ * a database connection. Also be sure that you have done that initialization before opening a
+ * database connection.
+ *
+ */
+static VALUE
+pg_s_init_openssl(VALUE self, VALUE do_ssl, VALUE do_crypto)
+{
+	UNUSED( self );
+	PQinitOpenSSL(pg_to_bool_int(do_ssl), pg_to_bool_int(do_crypto));
+	return Qnil;
+}
+
+
+/*
+ * call-seq:
+ *    PG.init_ssl(do_ssl)  -> nil
+ *
+ * Allows applications to select which security libraries to initialize.
+ *
+ * This function is equivalent to <tt>PG.init_openssl(do_ssl, do_ssl)</tt> . It is sufficient for
+ * applications that initialize both or neither of OpenSSL and libcrypto.
+ */
+static VALUE
+pg_s_init_ssl(VALUE self, VALUE do_ssl)
+{
+	UNUSED( self );
+	PQinitSSL(pg_to_bool_int(do_ssl));
+	return Qnil;
+}
+
+
+/**************************************************************************
+ * Initializer
+ **************************************************************************/
+
+void
+Init_pg_ext()
+{
+	if( RTEST(rb_eval_string("ENV['PG_SKIP_DEPRECATION_WARNING']")) ){
+		/* Set all bits to disable all deprecation warnings. */
+		pg_skip_deprecation_warning = 0xFFFF;
+	} else {
+		pg_skip_deprecation_warning = 0;
+	}
+
+	rb_mPG = rb_define_module( "PG" );
+	rb_mPGconstants = rb_define_module_under( rb_mPG, "Constants" );
+
+	/*************************
+	 *  PG module methods
+	 *************************/
+	rb_define_singleton_method( rb_mPG, "library_version", pg_s_library_version, 0 );
+	rb_define_singleton_method( rb_mPG, "isthreadsafe", pg_s_threadsafe_p, 0 );
+	SINGLETON_ALIAS( rb_mPG, "is_threadsafe?", "isthreadsafe" );
+	SINGLETON_ALIAS( rb_mPG, "threadsafe?", "isthreadsafe" );
+
+  rb_define_singleton_method( rb_mPG, "init_openssl", pg_s_init_openssl, 2 );
+  rb_define_singleton_method( rb_mPG, "init_ssl", pg_s_init_ssl, 1 );
+
+
+	/******     PG::Connection CLASS CONSTANTS: Connection Status     ******/
+
+	/* Connection succeeded */
+	rb_define_const(rb_mPGconstants, "CONNECTION_OK", INT2FIX(CONNECTION_OK));
+	/* Connection failed */
+	rb_define_const(rb_mPGconstants, "CONNECTION_BAD", INT2FIX(CONNECTION_BAD));
+
+	/******     PG::Connection CLASS CONSTANTS: Nonblocking connection status     ******/
+
+	/* Waiting for connection to be made. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_STARTED", INT2FIX(CONNECTION_STARTED));
+	/* Connection OK; waiting to send. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_MADE", INT2FIX(CONNECTION_MADE));
+	/* Waiting for a response from the server. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_AWAITING_RESPONSE", INT2FIX(CONNECTION_AWAITING_RESPONSE));
+	/* Received authentication; waiting for backend start-up to finish. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_AUTH_OK", INT2FIX(CONNECTION_AUTH_OK));
+	/* Negotiating SSL encryption. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_SSL_STARTUP", INT2FIX(CONNECTION_SSL_STARTUP));
+	/* Negotiating environment-driven parameter settings. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_SETENV", INT2FIX(CONNECTION_SETENV));
+	/* Internal state: connect() needed. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_NEEDED", INT2FIX(CONNECTION_NEEDED));
+
+	/******     PG::Connection CLASS CONSTANTS: Nonblocking connection polling status     ******/
+
+	/* Async connection is waiting to read */
+	rb_define_const(rb_mPGconstants, "PGRES_POLLING_READING", INT2FIX(PGRES_POLLING_READING));
+	/* Async connection is waiting to write */
+	rb_define_const(rb_mPGconstants, "PGRES_POLLING_WRITING", INT2FIX(PGRES_POLLING_WRITING));
+	/* Async connection failed or was reset */
+	rb_define_const(rb_mPGconstants, "PGRES_POLLING_FAILED", INT2FIX(PGRES_POLLING_FAILED));
+	/* Async connection succeeded */
+	rb_define_const(rb_mPGconstants, "PGRES_POLLING_OK", INT2FIX(PGRES_POLLING_OK));
+
+	/******     PG::Connection CLASS CONSTANTS: Transaction Status     ******/
+
+	/* Transaction is currently idle (#transaction_status) */
+	rb_define_const(rb_mPGconstants, "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_mPGconstants, "PQTRANS_ACTIVE", INT2FIX(PQTRANS_ACTIVE));
+	/* Transaction is currently idle, in a valid transaction block (#transaction_status) */
+	rb_define_const(rb_mPGconstants, "PQTRANS_INTRANS", INT2FIX(PQTRANS_INTRANS));
+	/* Transaction is currently idle, in a failed transaction block (#transaction_status) */
+	rb_define_const(rb_mPGconstants, "PQTRANS_INERROR", INT2FIX(PQTRANS_INERROR));
+	/* Transaction's connection is bad (#transaction_status) */
+	rb_define_const(rb_mPGconstants, "PQTRANS_UNKNOWN", INT2FIX(PQTRANS_UNKNOWN));
+
+	/******     PG::Connection CLASS CONSTANTS: Error Verbosity     ******/
+
+	/* Terse error verbosity level (#set_error_verbosity) */
+	rb_define_const(rb_mPGconstants, "PQERRORS_TERSE", INT2FIX(PQERRORS_TERSE));
+	/* Default error verbosity level (#set_error_verbosity) */
+	rb_define_const(rb_mPGconstants, "PQERRORS_DEFAULT", INT2FIX(PQERRORS_DEFAULT));
+	/* Verbose error verbosity level (#set_error_verbosity) */
+	rb_define_const(rb_mPGconstants, "PQERRORS_VERBOSE", INT2FIX(PQERRORS_VERBOSE));
+
+	/******     PG::Connection CLASS CONSTANTS: Check Server Status ******/
+
+	/* Server is accepting connections. */
+	rb_define_const(rb_mPGconstants, "PQPING_OK", INT2FIX(PQPING_OK));
+	/* Server is alive but rejecting connections. */
+	rb_define_const(rb_mPGconstants, "PQPING_REJECT", INT2FIX(PQPING_REJECT));
+	/* Could not establish connection. */
+	rb_define_const(rb_mPGconstants, "PQPING_NO_RESPONSE", INT2FIX(PQPING_NO_RESPONSE));
+	/* Connection not attempted (bad params). */
+	rb_define_const(rb_mPGconstants, "PQPING_NO_ATTEMPT", INT2FIX(PQPING_NO_ATTEMPT));
+
+	/******     PG::Connection CLASS CONSTANTS: Large Objects     ******/
+
+	/* Flag for #lo_creat, #lo_open -- open for writing */
+	rb_define_const(rb_mPGconstants, "INV_WRITE", INT2FIX(INV_WRITE));
+	/* Flag for #lo_creat, #lo_open -- open for reading */
+	rb_define_const(rb_mPGconstants, "INV_READ", INT2FIX(INV_READ));
+	/* Flag for #lo_lseek -- seek from object start */
+	rb_define_const(rb_mPGconstants, "SEEK_SET", INT2FIX(SEEK_SET));
+	/* Flag for #lo_lseek -- seek from current position */
+	rb_define_const(rb_mPGconstants, "SEEK_CUR", INT2FIX(SEEK_CUR));
+	/* Flag for #lo_lseek -- seek from object end */
+	rb_define_const(rb_mPGconstants, "SEEK_END", INT2FIX(SEEK_END));
+
+	/******     PG::Result CONSTANTS: result status      ******/
+
+	/* #result_status constant: The string sent to the server was empty. */
+	rb_define_const(rb_mPGconstants, "PGRES_EMPTY_QUERY", INT2FIX(PGRES_EMPTY_QUERY));
+	/* #result_status constant: Successful completion of a command returning no data. */
+	rb_define_const(rb_mPGconstants, "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_mPGconstants, "PGRES_TUPLES_OK", INT2FIX(PGRES_TUPLES_OK));
+	/* #result_status constant: Copy Out (from server) data transfer started. */
+	rb_define_const(rb_mPGconstants, "PGRES_COPY_OUT", INT2FIX(PGRES_COPY_OUT));
+	/* #result_status constant: Copy In (to server) data transfer started. */
+	rb_define_const(rb_mPGconstants, "PGRES_COPY_IN", INT2FIX(PGRES_COPY_IN));
+	/* #result_status constant: The server’s response was not understood. */
+	rb_define_const(rb_mPGconstants, "PGRES_BAD_RESPONSE", INT2FIX(PGRES_BAD_RESPONSE));
+	/* #result_status constant: A nonfatal error (a notice or warning) occurred. */
+	rb_define_const(rb_mPGconstants, "PGRES_NONFATAL_ERROR",INT2FIX(PGRES_NONFATAL_ERROR));
+	/* #result_status constant: A fatal error occurred. */
+	rb_define_const(rb_mPGconstants, "PGRES_FATAL_ERROR", INT2FIX(PGRES_FATAL_ERROR));
+	/* #result_status constant: Copy In/Out data transfer in progress. */
+	rb_define_const(rb_mPGconstants, "PGRES_COPY_BOTH", INT2FIX(PGRES_COPY_BOTH));
+	/* #result_status constant: Single tuple from larger resultset. */
+	rb_define_const(rb_mPGconstants, "PGRES_SINGLE_TUPLE", INT2FIX(PGRES_SINGLE_TUPLE));
+
+	/******     Result 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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "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_mPGconstants, "PG_DIAG_SOURCE_FUNCTION", INT2FIX(PG_DIAG_SOURCE_FUNCTION));
+
+#ifdef HAVE_CONST_PG_DIAG_TABLE_NAME
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific database object, the name of the schema containing that object, if any. */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_SCHEMA_NAME", INT2FIX(PG_DIAG_SCHEMA_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 *specific table, the name of the table. (When this field is present, the schema name
+	 * field provides the name of the table's schema.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_TABLE_NAME", INT2FIX(PG_DIAG_TABLE_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific table column, the name of the column. (When this field is present, the
+	 * schema and table name fields identify the table.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_COLUMN_NAME", INT2FIX(PG_DIAG_COLUMN_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific datatype, the name of the datatype. (When this field is present, the
+	 * schema name field provides the name of the datatype's schema.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_DATATYPE_NAME", INT2FIX(PG_DIAG_DATATYPE_NAME));
+
+	/* #result_error_field argument constant: If the error was associated with a
+	 * specific constraint, the name of the constraint. The table or domain that the
+	 * constraint belongs to is reported using the fields listed above. (For this
+	 * purpose, indexes are treated as constraints, even if they weren't created with
+	 * constraint syntax.) */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_CONSTRAINT_NAME", INT2FIX(PG_DIAG_CONSTRAINT_NAME));
+#endif
+
+	/* Invalid OID constant */
+	rb_define_const(rb_mPGconstants, "INVALID_OID", INT2FIX(InvalidOid));
+	rb_define_const(rb_mPGconstants, "InvalidOid", INT2FIX(InvalidOid));
+
+	/* Add the constants to the toplevel namespace */
+	rb_include_module( rb_mPG, rb_mPGconstants );
+
+	enc_pg2ruby = st_init_numtable();
+
+	/* Initialize the main extension classes */
+	init_pg_connection();
+	init_pg_result();
+	init_pg_errors();
+	init_pg_type_map();
+	init_pg_type_map_all_strings();
+	init_pg_type_map_by_class();
+	init_pg_type_map_by_column();
+	init_pg_type_map_by_mri_type();
+	init_pg_type_map_by_oid();
+	init_pg_type_map_in_ruby();
+	init_pg_coder();
+	init_pg_text_encoder();
+	init_pg_text_decoder();
+	init_pg_binary_encoder();
+	init_pg_binary_decoder();
+	init_pg_copycoder();
+	init_pg_tuple();
+}
+