pg 1.3.0.rc2-x64-mingw-ucrt

data/ext/extconf.rb

@@ -0,0 +1,165 @@
+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("gvl-unlock", true)
+	$defs.push( "-DENABLE_GVL_UNLOCK" )
+	$stderr.puts "Calling libpq with GVL unlocked"
+else
+	$stderr.puts "Calling libpq with GVL locked"
+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
+
+		# Windows traditionally stores DLLs beside executables, not in libdir
+		dlldir = RUBY_PLATFORM=~/mingw|mswin/ ? `"#{pgconfig}" --bindir`.chomp : libdir
+
+	elsif checking_for "libpq per pkg-config" do
+			_cflags, ldflags, _libs = pkg_config("libpq")
+			dlldir = ldflags && ldflags[/-L([^ ]+)/] && $1
+		end
+
+	else
+		incdir, libdir = dir_config 'pg'
+		dlldir = libdir
+	end
+
+	# 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 dlldir && RbConfig::CONFIG["RPATHFLAG"].to_s.empty?
+		append_ldflags "-Wl,-rpath,#{dlldir.quote}"
+	end
+end
+
+$stderr.puts "Using libpq from #{dlldir}"
+
+File.write("postgresql_lib_path.rb", <<-EOT)
+module PG
+	POSTGRESQL_LIB_PATH = #{dlldir.inspect}
+end
+EOT
+$INSTALLFILES = {
+	"./postgresql_lib_path.rb" => "$(RUBYLIBDIR)/pg/"
+}
+
+if RUBY_VERSION >= '2.3.0' && /solaris/ =~ RUBY_PLATFORM
+	append_cppflags( '-D__EXTENSIONS__' )
+end
+
+begin
+	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'] )
+
+rescue SystemExit => err
+	install_text = case RUBY_PLATFORM
+	when /linux/
+	<<-EOT
+Please install libpq or postgresql client package like so:
+  sudo apt install libpq-dev
+  sudo yum install postgresql-devel
+  sudo zypper in postgresql-devel
+  sudo pacman -S postgresql-libs
+EOT
+	when /darwin/
+	<<-EOT
+Please install libpq or postgresql client package like so:
+  brew install libpq
+EOT
+	when /mingw/
+	<<-EOT
+Please install libpq or postgresql client package like so:
+  ridk exec sh -c "pacman -S ${MINGW_PACKAGE_PREFIX}-postgresql"
+EOT
+	else
+	<<-EOT
+Please install libpq or postgresql client package.
+EOT
+	end
+
+	$stderr.puts <<-EOT
+*****************************************************************************
+
+Unable to find PostgreSQL client library.
+
+#{install_text}
+or try again with:
+  gem install pg -- --with-pg-config=/path/to/pg_config
+
+or set library paths manually with:
+  gem install pg -- --with-pg-include=/path/to/libpq-fe.h/ --with-pg-lib=/path/to/libpq.so/
+
+EOT
+	raise
+end
+
+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
+
+have_func 'PQconninfo' or
+	abort "Your PostgreSQL is too old. Either install an older version " +
+	      "of this gem or upgrade your database to at least PostgreSQL-9.3."
+# optional headers/functions
+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 'PQenterPipelineMode' # since PostgreSQL-14
+have_func 'timegm'
+have_func 'rb_gc_adjust_memory_usage' # since ruby-2.4
+have_func 'rb_gc_mark_movable' # since ruby-2.7
+have_func 'rb_io_wait' # since ruby-3.0
+
+# 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,21 @@
+/*
+ * 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
+
+#ifdef ENABLE_GVL_UNLOCK
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_SKELETON );
+#endif
+FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB );
+#ifdef ENABLE_GVL_UNLOCK
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_SKELETON );
+#endif
+FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_STUB );

data/ext/gvl_wrappers.h

@@ -0,0 +1,264 @@
+/*
+ * 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>
+
+#ifdef RUBY_EXTCONF_H
+#	include RUBY_EXTCONF_H
+#endif
+
+#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; \
+	}
+
+#ifdef ENABLE_GVL_UNLOCK
+#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){ \
+		when_non_void( return ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
+	}
+#endif
+
+#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; \
+	}
+
+#ifdef ENABLE_GVL_UNLOCK
+#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){ \
+		when_non_void( return ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
+	}
+#endif
+
+#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_PQping(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(PQping, GVL_TYPE_NONVOID, PGPing, const char *, conninfo) \
+	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 */