pg 0.15.1 → 1.2.3

data/ext/extconf.rb

@@ -15,29 +15,40 @@ if pgdir = with_config( 'pg' )
 	ENV['PATH'] = "#{pgdir}/bin" + File::PATH_SEPARATOR + ENV['PATH']
 end
 
-if ENV['CROSS_COMPILING']
-	$LDFLAGS << " -L#{CONFIG['libdir']}"
-
-	# Link against all required libraries for static build, if they are available
-	have_library( 'crypt32', 'CertOpenStore' ) && append_library( $libs, 'crypt32' )
-	have_library( 'gdi32', 'CreateDC' ) && append_library( $libs, 'gdi32' )
-	have_library( 'secur32' ) && append_library( $libs, 'secur32' )
-	have_library( 'ws2_32', 'WSASocket') && append_library( $libs, 'ws2_32' )
-	have_library( 'crypto', 'BIO_new' ) && append_library( $libs, 'crypto' )
-	have_library( 'ssl', 'SSL_new' ) && append_library( $libs, 'ssl' )
-end
-
-dir_config 'pg'
-
-if pgconfig = ( with_config('pg-config') || with_config('pg_config') || find_executable('pg_config') )
-	$stderr.puts "Using config values from %s" % [ pgconfig ]
-	$CPPFLAGS << " -I%s" % [ `"#{pgconfig}" --includedir`.chomp ]
+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'
 
-	libdir = `"#{pgconfig}" --libdir`.chomp
-	$LDFLAGS << " -L%s -Wl,-rpath,%s" % [ libdir, libdir ]
 else
-	$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
-		" --with-pg-config=/path/to/pg_config"
+	# 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"
@@ -49,42 +60,34 @@ abort "Can't find the PostgreSQL client library (libpq)" unless
 	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 'PQconnectionUsedPassword' or
+have_func 'PQsetSingleRowMode' or
 	abort "Your PostgreSQL is too old. Either install an older version " +
-	      "of this gem or upgrade your database."
-have_func 'PQisthreadsafe'
-have_func 'PQprepare'
-have_func 'PQexecParams'
-have_func 'PQescapeString'
-have_func 'PQescapeStringConn'
-have_func 'PQescapeLiteral'
-have_func 'PQescapeIdentifier'
-have_func 'PQgetCancel'
-have_func 'lo_create'
-have_func 'pg_encoding_to_char'
-have_func 'pg_char_to_encoding'
-have_func 'PQsetClientEncoding'
-have_func 'PQlibVersion'
-have_func 'PQping'
-have_func 'PQsetSingleRowMode'
-
-have_func 'rb_encdb_alias'
-have_func 'rb_enc_alias'
-have_func 'rb_thread_call_without_gvl'
-have_func 'rb_thread_call_with_gvl'
-have_func 'rb_thread_fd_select'
-have_func 'rb_w32_wrap_io_handle'
-
-have_const 'PGRES_COPY_BOTH', 'libpq-fe.h'
-have_const 'PGRES_SINGLE_TUPLE', 'libpq-fe.h'
-
-$defs.push( "-DHAVE_ST_NOTIFY_EXTRA" ) if
-	have_struct_member 'struct pgNotify', 'extra', 'libpq-fe.h'
+	      "of this gem or upgrade your database to at least PostgreSQL-9.2."
+have_func 'PQconninfo' # since PostgreSQL-9.3
+have_func 'PQsslAttribute' # since PostgreSQL-9.5
+have_func 'PQresultVerboseErrorMessage' # since PostgreSQL-9.6
+have_func 'PQencryptPasswordConn' # since PostgreSQL-10
+have_func 'PQresultMemorySize' # since PostgreSQL-12
+have_func 'timegm'
+have_func 'rb_gc_adjust_memory_usage' # since ruby-2.4
 
 # unistd.h confilicts with ruby/win32.h when cross compiling for win32 and ruby 1.9.1
 have_header 'unistd.h'
-have_header 'ruby/st.h' or have_header 'st.h' or abort "pg currently requires the ruby/st.h header"
+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

@@ -5,6 +5,10 @@
 
 #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 );

data/ext/gvl_wrappers.h

@@ -15,14 +15,7 @@
 #ifndef __gvl_wrappers_h
 #define __gvl_wrappers_h
 
-#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
-extern void *rb_thread_call_with_gvl(void *(*func)(void *), void *data1);
-#endif
-
-#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
-				 rb_unblock_function_t *ubf, void *data2);
-#endif
+#include <ruby/thread.h>
 
 #define DEFINE_PARAM_LIST1(type, name) \
 	name,
@@ -53,21 +46,14 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 		return NULL; \
 	}
 
-#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-	#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; ) \
-		}
-#else
-	#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
-		rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
-			return name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
-		}
-#endif
+#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);
@@ -80,21 +66,14 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 		return NULL; \
 	}
 
-#if defined(HAVE_RB_THREAD_CALL_WITH_GVL)
-	#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; ) \
-		}
-#else
-	#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
-		rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
-			return name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
-		}
-#endif
+#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
@@ -104,6 +83,18 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
  * 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)
 
@@ -149,8 +140,62 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 	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) \
@@ -161,6 +206,17 @@ extern void *rb_thread_call_without_gvl(void *(*func)(void *), void *data1,
 	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 );
 

data/ext/pg.c

@@ -1,12 +1,13 @@
 /*
  * pg.c - Toplevel extension
- * $Id: pg.c,v d0c5d5f7f1e8 2012/12/26 21:09:28 kanis $
+ * $Id$
  *
  * 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>
@@ -15,10 +16,10 @@
  * See Contributors.rdoc for the many additional fine people that have contributed
  * to this library over the years.
  *
- * Copyright (c) 1997-2012 by the authors.
+ * Copyright (c) 1997-2019 by the authors.
  *
  * You may redistribute this software under the same terms as Ruby itself; see
- * http://www.ruby-lang.org/en/LICENSE.txt or the LICENSE file in the source
+ * 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
@@ -47,8 +48,8 @@
 
 #include "pg.h"
 
+int pg_skip_deprecation_warning;
 VALUE rb_mPG;
-VALUE rb_ePGerror;
 VALUE rb_mPGconstants;
 
 
@@ -69,7 +70,6 @@ VALUE rb_mPGconstants;
  * M17n functions
  */
 
-#ifdef M17N_SUPPORTED
 /**
  * The mapping from canonical encoding names in PostgreSQL to ones in Ruby.
  */
@@ -124,24 +124,6 @@ const char * const (pg_enc_pg2ruby_mapping[][2]) = {
  * A cache of mapping from PostgreSQL's encoding indices to Ruby's rb_encoding*s.
  */
 static struct st_table *enc_pg2ruby;
-static ID s_id_index;
-
-
-/*
- * Get the index of encoding +val+.
- * :FIXME: Look into replacing this with rb_enc_get_index() since 1.9.1 isn't really
- * used anymore.
- */
-int
-pg_enc_get_index(VALUE val)
-{
-	int i = ENCODING_GET_INLINED(val);
-	if (i == ENCODING_INLINE_MAX) {
-		VALUE iv = rb_ivar_get(val, s_id_index);
-		i = NUM2INT(iv);
-	}
-	return i;
-}
 
 
 /*
@@ -161,9 +143,6 @@ pg_find_or_create_johab(void)
 	}
 
 	enc_index = rb_define_dummy_encoding(aliases[0]);
-	for (i = 1; i < sizeof(aliases)/sizeof(aliases[0]); ++i) {
-		ENC_ALIAS(aliases[i], aliases[0]);
-	}
 	return rb_enc_from_index(enc_index);
 }
 
@@ -247,14 +226,55 @@ pg_get_rb_encoding_as_pg_encoding( rb_encoding *enc )
 	return encname;
 }
 
-#endif /* M17N_SUPPORTED */
+
+/*
+ * Ensures that the given string has enough capacity to take expand_len
+ * more data bytes. The new data part of the String is not initialized.
+ *
+ * current_out must be a pointer within the data part of the String object.
+ * This pointer is returned and possibly adjusted, because the location of the data
+ * part of the String can change through this function.
+ *
+ * PG_RB_STR_ENSURE_CAPA can be used to do fast inline checks of the remaining capacity.
+ * end_capa it is then set to the first byte after the currently reserved memory,
+ * if not NULL.
+ *
+ * Before the String can be used with other string functions or returned to Ruby space,
+ * the string length has to be set with rb_str_set_len().
+ *
+ * Usage example:
+ *
+ *   VALUE string;
+ *   char *current_out, *end_capa;
+ *   PG_RB_STR_NEW( string, current_out, end_capa );
+ *   while( data_is_going_to_be_processed ){
+ *     PG_RB_STR_ENSURE_CAPA( string, 2, current_out, end_capa );
+ *     *current_out++ = databyte1;
+ *     *current_out++ = databyte2;
+ *   }
+ *   rb_str_set_len( string, current_out - RSTRING_PTR(string) );
+ *
+ */
+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
  **************************************************************************/
 
-#ifdef HAVE_PQLIBVERSION
 /*
  * call-seq:
  *   PG.library_version -> Integer
@@ -272,7 +292,6 @@ pg_s_library_version(VALUE self)
 	UNUSED( self );
 	return INT2NUM(PQlibVersion());
 }
-#endif
 
 
 /*
@@ -290,6 +309,66 @@ pg_s_threadsafe_p(VALUE self)
 	return PQisthreadsafe() ? Qtrue : Qfalse;
 }
 
+static int
+pg_to_bool_int(VALUE value)
+{
+	switch( TYPE(value) ){
+		case T_FALSE:
+			return 0;
+		case T_TRUE:
+			return 1;
+		default:
+			return NUM2INT(value);
+	}
+}
+
+/*
+ * call-seq:
+ *    PG.init_openssl(do_ssl, do_crypto)  -> nil
+ *
+ * Allows applications to select which security libraries to initialize.
+ *
+ * If your application initializes libssl and/or libcrypto libraries and libpq is
+ * built with SSL support, you should call PG.init_openssl() to tell libpq that the
+ * libssl and/or libcrypto libraries have been initialized by your application,
+ * so that libpq will not also initialize those libraries.
+ *
+ * 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;
+}
 
 
 /**************************************************************************
@@ -299,26 +378,27 @@ pg_s_threadsafe_p(VALUE self)
 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_ePGerror = rb_define_class_under( rb_mPG, "Error", rb_eStandardError );
 	rb_mPGconstants = rb_define_module_under( rb_mPG, "Constants" );
 
 	/*************************
 	 *  PG module methods
 	 *************************/
-#ifdef HAVE_PQLIBVERSION
 	rb_define_singleton_method( rb_mPG, "library_version", pg_s_library_version, 0 );
-#endif
 	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" );
 
-	/*************************
-	 *  PG::Error
-	 *************************/
-	rb_define_alias( rb_ePGerror, "error", "message" );
-	rb_define_attr( rb_ePGerror, "connection", 1, 0 );
-	rb_define_attr( rb_ePGerror, "result", 1, 0 );
+  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     ******/
 
@@ -341,7 +421,7 @@ Init_pg_ext()
 	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. */
+	/* Internal state - PG.connect() needed. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_NEEDED", INT2FIX(CONNECTION_NEEDED));
 
 	/******     PG::Connection CLASS CONSTANTS: Nonblocking connection polling status     ******/
@@ -357,27 +437,48 @@ Init_pg_ext()
 
 	/******     PG::Connection CLASS CONSTANTS: Transaction Status     ******/
 
-	/* Transaction is currently idle (#transaction_status) */
+	/* Transaction is currently idle ( Connection#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) */
+	/* Transaction is currently active; query has been sent to the server, but not yet completed. ( Connection#transaction_status ) */
 	rb_define_const(rb_mPGconstants, "PQTRANS_ACTIVE", INT2FIX(PQTRANS_ACTIVE));
-	/* Transaction is currently idle, in a valid transaction block (#transaction_status) */
+	/* Transaction is currently idle, in a valid transaction block ( Connection#transaction_status ) */
 	rb_define_const(rb_mPGconstants, "PQTRANS_INTRANS", INT2FIX(PQTRANS_INTRANS));
-	/* Transaction is currently idle, in a failed transaction block (#transaction_status) */
+	/* Transaction is currently idle, in a failed transaction block ( Connection#transaction_status ) */
 	rb_define_const(rb_mPGconstants, "PQTRANS_INERROR", INT2FIX(PQTRANS_INERROR));
-	/* Transaction's connection is bad (#transaction_status) */
+	/* Transaction's connection is bad ( Connection#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) */
+	/* Error verbosity level ( Connection#set_error_verbosity ).
+	 * In TERSE mode, returned messages include severity, primary text, and position only; this will normally fit on a single line. */
 	rb_define_const(rb_mPGconstants, "PQERRORS_TERSE", INT2FIX(PQERRORS_TERSE));
-	/* Default error verbosity level (#set_error_verbosity) */
+	/* Error verbosity level ( Connection#set_error_verbosity ).
+	 * The DEFAULT mode produces messages that include the above plus any detail, hint, or context fields (these might span multiple lines). */
 	rb_define_const(rb_mPGconstants, "PQERRORS_DEFAULT", INT2FIX(PQERRORS_DEFAULT));
-	/* Verbose error verbosity level (#set_error_verbosity) */
+	/* Error verbosity level ( Connection#set_error_verbosity ).
+	 * The VERBOSE mode includes all available fields. */
 	rb_define_const(rb_mPGconstants, "PQERRORS_VERBOSE", INT2FIX(PQERRORS_VERBOSE));
 
-#ifdef HAVE_PQPING
+/* PQERRORS_SQLSTATE was introduced in PG-12 together with PQresultMemorySize() */
+#ifdef HAVE_PQRESULTMEMORYSIZE
+	/* Error verbosity level ( Connection#set_error_verbosity ).
+	 * The SQLSTATE mode includes only the error severity and the SQLSTATE error code, if one is available (if not, the output is like TERSE mode).
+	 *
+	 * Available since PostgreSQL-12.
+	 */
+	rb_define_const(rb_mPGconstants, "PQERRORS_SQLSTATE", INT2FIX(PQERRORS_SQLSTATE));
+#endif
+
+#ifdef HAVE_PQRESULTVERBOSEERRORMESSAGE
+	/* See Connection#set_error_context_visibility */
+	rb_define_const(rb_mPGconstants, "PQSHOW_CONTEXT_NEVER", INT2FIX(PQSHOW_CONTEXT_NEVER));
+	/* See Connection#set_error_context_visibility */
+	rb_define_const(rb_mPGconstants, "PQSHOW_CONTEXT_ERRORS", INT2FIX(PQSHOW_CONTEXT_ERRORS));
+	/* See Connection#set_error_context_visibility */
+	rb_define_const(rb_mPGconstants, "PQSHOW_CONTEXT_ALWAYS", INT2FIX(PQSHOW_CONTEXT_ALWAYS));
+#endif
+
 	/******     PG::Connection CLASS CONSTANTS: Check Server Status ******/
 
 	/* Server is accepting connections. */
@@ -388,124 +489,162 @@ Init_pg_ext()
 	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));
-#endif
 
 	/******     PG::Connection CLASS CONSTANTS: Large Objects     ******/
 
-	/* Flag for #lo_creat, #lo_open -- open for writing */
+	/* Flag for Connection#lo_creat, Connection#lo_open -- open for writing */
 	rb_define_const(rb_mPGconstants, "INV_WRITE", INT2FIX(INV_WRITE));
-	/* Flag for #lo_creat, #lo_open -- open for reading */
+	/* Flag for Connection#lo_creat, Connection#lo_open -- open for reading */
 	rb_define_const(rb_mPGconstants, "INV_READ", INT2FIX(INV_READ));
-	/* Flag for #lo_lseek -- seek from object start */
+	/* Flag for Connection#lo_lseek -- seek from object start */
 	rb_define_const(rb_mPGconstants, "SEEK_SET", INT2FIX(SEEK_SET));
-	/* Flag for #lo_lseek -- seek from current position */
+	/* Flag for Connection#lo_lseek -- seek from current position */
 	rb_define_const(rb_mPGconstants, "SEEK_CUR", INT2FIX(SEEK_CUR));
-	/* Flag for #lo_lseek -- seek from object end */
+	/* Flag for Connection#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. */
+	/* Result#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. */
+	/* Result#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). */
+	/* Result#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. */
+	/* Result#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. */
+	/* Result#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. */
+	/* Result#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. */
+	/* Result#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. */
+	/* Result#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. */
-#ifdef HAVE_CONST_PGRES_COPY_BOTH
+	/* Result#result_status constant - Copy In/Out data transfer in progress. */
 	rb_define_const(rb_mPGconstants, "PGRES_COPY_BOTH", INT2FIX(PGRES_COPY_BOTH));
-#endif
-	/* #result_status constant: Single tuple from larger resultset. */
-#ifdef HAVE_CONST_PGRES_SINGLE_TUPLE
+	/* Result#result_status constant - Single tuple from larger resultset. */
 	rb_define_const(rb_mPGconstants, "PGRES_SINGLE_TUPLE", INT2FIX(PGRES_SINGLE_TUPLE));
-#endif
 
 	/******     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.
+	/* Result#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.
+#ifdef PG_DIAG_SEVERITY_NONLOCALIZED
+	/* Result#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).
+	 * This is identical to the PG_DIAG_SEVERITY field except that the contents are never localized.
+	 *
+	 * Available since PostgreSQL-9.6
+	 */
+	rb_define_const(rb_mPGconstants, "PG_DIAG_SEVERITY_NONLOCALIZED", INT2FIX(PG_DIAG_SEVERITY_NONLOCALIZED));
+#endif
+	/* Result#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 error handling) in response to a particular database error.
+	 * For a list of the possible SQLSTATE codes, see Appendix A.
+	 * This field 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. */
+	/* Result#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.
+	/* Result#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.
+	/* Result#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.
+	/* Result#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 first 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.
+	/* Result#result_error_field argument constant
+	 *
+	 * This is defined the same as the PG_DIAG_STATEMENT_POSITION field, 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 field will always appear when this field 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.
+	/* Result#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.
+	/* Result#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 first.
 	 */
-
 	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. */
+	/* Result#result_error_field argument constant
+	 *
+	 * The file 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. */
+	/* Result#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. */
+	/* Result#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 PG_DIAG_TABLE_NAME
+	/* Result#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#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#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#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#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));
@@ -513,13 +652,26 @@ Init_pg_ext()
 	/* Add the constants to the toplevel namespace */
 	rb_include_module( rb_mPG, rb_mPGconstants );
 
-#ifdef M17N_SUPPORTED
 	enc_pg2ruby = st_init_numtable();
-	s_id_index = rb_intern("@encoding");
-#endif
 
 	/* Initialize the main extension classes */
 	init_pg_connection();
 	init_pg_result();
+	init_pg_errors();
+	init_pg_type_map();
+	init_pg_type_map_all_strings();
+	init_pg_type_map_by_class();
+	init_pg_type_map_by_column();
+	init_pg_type_map_by_mri_type();
+	init_pg_type_map_by_oid();
+	init_pg_type_map_in_ruby();
+	init_pg_coder();
+	init_pg_text_encoder();
+	init_pg_text_decoder();
+	init_pg_binary_encoder();
+	init_pg_binary_decoder();
+	init_pg_copycoder();
+	init_pg_recordcoder();
+	init_pg_tuple();
 }