pg 1.5.4 → 1.6.1

data/ext/extconf.rb

@@ -1,7 +1,6 @@
 require 'pp'
 require 'mkmf'
 
-
 if ENV['MAINTAINER_MODE']
 	$stderr.puts "Maintainer mode enabled."
 	$CFLAGS <<
@@ -9,6 +8,8 @@ if ENV['MAINTAINER_MODE']
 		' -ggdb' <<
 		' -DDEBUG' <<
 		' -pedantic'
+	$LDFLAGS <<
+		' -ggdb'
 end
 
 if pgdir = with_config( 'pg' )
@@ -22,12 +23,163 @@ else
 	$stderr.puts "Calling libpq with GVL locked"
 end
 
-if enable_config("windows-cross")
+if gem_platform=with_config("cross-build")
+	gem 'mini_portile2', '~>2.1'
+	require 'mini_portile2'
+
+	OPENSSL_VERSION = ENV['OPENSSL_VERSION'] || '3.5.1'
+	OPENSSL_SOURCE_URI = "http://www.openssl.org/source/openssl-#{OPENSSL_VERSION}.tar.gz"
+
+	KRB5_VERSION = ENV['KRB5_VERSION'] || '1.21.3'
+	KRB5_SOURCE_URI = "http://kerberos.org/dist/krb5/#{KRB5_VERSION[/^(\d+\.\d+)/]}/krb5-#{KRB5_VERSION}.tar.gz"
+
+	POSTGRESQL_VERSION = ENV['POSTGRESQL_VERSION'] || '17.5'
+	POSTGRESQL_SOURCE_URI = "http://ftp.postgresql.org/pub/source/v#{POSTGRESQL_VERSION}/postgresql-#{POSTGRESQL_VERSION}.tar.bz2"
+
+	class BuildRecipe < MiniPortile
+		def initialize(name, version, files)
+			super(name, version)
+			self.files = files
+			rootdir = File.expand_path('../..', __FILE__)
+			self.target = File.join(rootdir, "ports")
+			self.patch_files = Dir[File.join(target, "patches", self.name, self.version, "*.patch")].sort
+		end
+
+		def port_path
+			"#{target}/#{RUBY_PLATFORM}"
+		end
+
+		def cook_and_activate
+			checkpoint = File.join(self.target, "#{self.name}-#{self.version}-#{RUBY_PLATFORM}.installed")
+			unless File.exist?(checkpoint)
+				self.cook
+				FileUtils.touch checkpoint
+			end
+			self.activate
+			self
+		end
+	end
+
+	openssl_platform = with_config("openssl-platform")
+	toolchain = with_config("toolchain")
+
+	openssl_recipe = BuildRecipe.new("openssl", OPENSSL_VERSION, [OPENSSL_SOURCE_URI]).tap do |recipe|
+		class << recipe
+			attr_accessor :openssl_platform
+			def configure
+				envs = []
+				envs << "CFLAGS=-DDSO_WIN32 -DOPENSSL_THREADS" if RUBY_PLATFORM =~ /mingw|mswin/
+				envs << "CFLAGS=-fPIC -DOPENSSL_THREADS" if RUBY_PLATFORM =~ /linux|darwin/
+				execute('configure', ['env', *envs, "./Configure", openssl_platform, "threads", "-static", "CROSS_COMPILE=#{host}-", configure_prefix], altlog: "config.log")
+			end
+			def compile
+				execute('compile', "#{make_cmd} build_libs")
+			end
+			def install
+				execute('install', "#{make_cmd} install_dev")
+			end
+		end
+
+		recipe.openssl_platform = openssl_platform
+		recipe.host = toolchain
+		recipe.cook_and_activate
+	end
+
+	if RUBY_PLATFORM =~ /linux|darwin/
+		krb5_recipe = BuildRecipe.new("krb5", KRB5_VERSION, [KRB5_SOURCE_URI]).tap do |recipe|
+			class << recipe
+				def work_path
+					File.join(super, "src")
+				end
+				def configure
+					if RUBY_PLATFORM=~/darwin/
+						ENV["CC"] = host[/^.*[^\.\d]/] + "-clang"
+						ENV["CXX"] = host[/^.*[^\.\d]/] + "-c++"
+
+						# Manually set the correct values for configure checks that libkrb5 won't be
+						# able to perform because we're cross-compiling.
+						ENV["krb5_cv_attr_constructor_destructor"] = "yes"
+						ENV["ac_cv_func_regcomp"] = "yes"
+						ENV["ac_cv_printf_positional"] = "yes"
+					end
+					super
+				end
+			end
+			# We specify -fcommon to get around duplicate definition errors in recent gcc.
+			# See https://github.com/cockroachdb/cockroach/issues/49734
+			recipe.configure_options << "CFLAGS=-fcommon#{" -fPIC" if RUBY_PLATFORM =~ /linux/}"
+			recipe.configure_options << "LDFLAGS=-framework Kerberos" if RUBY_PLATFORM =~ /darwin/
+			recipe.configure_options << "--without-keyutils"
+			recipe.configure_options << "--disable-nls"
+			recipe.configure_options << "--disable-silent-rules"
+			recipe.configure_options << "--without-system-verto"
+			recipe.configure_options << "krb5_cv_attr_constructor_destructor=yes"
+			recipe.configure_options << "ac_cv_func_regcomp=yes"
+			recipe.configure_options << "ac_cv_printf_positional=yes"
+			recipe.host = toolchain
+			recipe.cook_and_activate
+		end
+	end
+
+	# We build a libpq library file which static links OpenSSL and krb5.
+	# Our builtin libpq is referenced in different ways depending on the OS:
+	# - Window: Add the ports directory at runtime per RubyInstaller::Runtime.add_dll_directory
+	#     The file is called "libpq.dll"
+	# - Linux: Add a rpath to pg_ext.so which references the ports directory.
+	#     The file is called "libpq-ruby-pg.so.1" to avoid loading of system libpq by accident.
+	# - Macos: Add a reference with relative path in pg_ext.so to the ports directory.
+	#     The file is called "libpq-ruby-pg.1.dylib" to avoid loading of other libpq by accident.
+	libpq_orig, libpq_rubypg = case RUBY_PLATFORM
+	when /linux/ then ["libpq.so.5", "libpq-ruby-pg.so.1"]
+	when /darwin/ then ["libpq.5.dylib", "libpq-ruby-pg.1.dylib"]
+	# when /mingw/ then ["libpq.dll", "libpq.dll"] # renaming not needed
+	end
+
+	postgresql_recipe = BuildRecipe.new("postgresql", POSTGRESQL_VERSION, [POSTGRESQL_SOURCE_URI]).tap do |recipe|
+		class << recipe
+			def configure_defaults
+				[
+					"--target=#{host}",
+					"--host=#{host}",
+					'--with-openssl',
+					*(RUBY_PLATFORM=~/linux|darwin/ ? ['--with-gssapi'] : []),
+					'--without-zlib',
+					'--without-icu',
+					'--without-readline',
+					'ac_cv_search_gss_store_cred_into=',
+				]
+			end
+			def compile
+				execute 'compile include', "#{make_cmd} -C src/include install"
+				execute 'compile interfaces', "#{make_cmd} -C src/interfaces install"
+			end
+			def install
+			end
+		end
+
+		recipe.host = toolchain
+		recipe.configure_options << "CFLAGS=#{" -fPIC" if RUBY_PLATFORM =~ /linux|darwin/}"
+		recipe.configure_options << "LDFLAGS=-L#{openssl_recipe.path}/lib -L#{openssl_recipe.path}/lib64 -L#{openssl_recipe.path}/lib-arm64 #{"-Wl,-soname,#{libpq_rubypg} -lgssapi_krb5 -lkrb5 -lk5crypto -lkrb5support -ldl" if RUBY_PLATFORM =~ /linux/} #{"-Wl,-install_name,@loader_path/../../ports/#{gem_platform}/lib/#{libpq_rubypg} -lgssapi_krb5 -lkrb5 -lk5crypto -lkrb5support -lresolv -framework Kerberos" if RUBY_PLATFORM =~ /darwin/}"
+		recipe.configure_options << "LIBS=-lkrb5 -lcom_err -lk5crypto -lkrb5support -lresolv" if RUBY_PLATFORM =~ /linux/
+		recipe.configure_options << "LIBS=-lssl -lwsock32 -lgdi32 -lws2_32 -lcrypt32" if RUBY_PLATFORM =~ /mingw|mswin/
+		recipe.configure_options << "CPPFLAGS=-I#{openssl_recipe.path}/include"
+		recipe.cook_and_activate
+	end
+
+	# Use our own library name for libpq to avoid loading of system libpq by accident.
+	FileUtils.ln_sf File.join(postgresql_recipe.port_path, "lib/#{libpq_orig}"),
+			File.join(postgresql_recipe.port_path, "lib/#{libpq_rubypg}")
 	# Avoid dependency to external libgcc.dll on x86-mingw32
-	$LDFLAGS << " -static-libgcc"
+	$LDFLAGS << " -static-libgcc" if RUBY_PLATFORM =~ /mingw|mswin/
+	# Avoid: "libpq.so: undefined reference to `dlopen'" in cross-ruby-2.7.8
+	$LDFLAGS << " -Wl,--no-as-needed" if RUBY_PLATFORM !~ /aarch64|arm64|darwin/
+	# Find libpq in the ports directory coming from lib/3.x
+	# It is shared between all compiled ruby versions.
+	$LDFLAGS << " '-Wl,-rpath=$$ORIGIN/../../ports/#{gem_platform}/lib'" if RUBY_PLATFORM =~ /linux/
 	# Don't use pg_config for cross build, but --with-pg-* path options
-	dir_config 'pg'
+	dir_config('pg', "#{postgresql_recipe.path}/include", "#{postgresql_recipe.path}/lib")
 
+	$defs.push( "-DPG_IS_BINARY_GEM")
 else
 	# Native build
 
@@ -77,7 +229,7 @@ $INSTALLFILES = {
 	"./postgresql_lib_path.rb" => "$(RUBYLIBDIR)/pg/"
 }
 
-if RUBY_VERSION >= '2.3.0' && /solaris/ =~ RUBY_PLATFORM
+if /solaris/ =~ RUBY_PLATFORM
 	append_cppflags( '-D__EXTENSIONS__' )
 end
 
@@ -142,25 +294,20 @@ if /mingw/ =~ RUBY_PLATFORM && RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
 	end
 end
 
-have_func 'PQconninfo', 'libpq-fe.h' or
+have_func 'PQencryptPasswordConn', 'libpq-fe.h' or # since PostgreSQL-10
 	abort "Your PostgreSQL is too old. Either install an older version " +
-	      "of this gem or upgrade your database to at least PostgreSQL-9.3."
+	      "of this gem or upgrade your database to at least PostgreSQL-10."
 # optional headers/functions
-have_func 'PQsslAttribute', 'libpq-fe.h' # since PostgreSQL-9.5
-have_func 'PQresultVerboseErrorMessage', 'libpq-fe.h' # since PostgreSQL-9.6
-have_func 'PQencryptPasswordConn', 'libpq-fe.h' # since PostgreSQL-10
 have_func 'PQresultMemorySize', 'libpq-fe.h' # since PostgreSQL-12
 have_func 'PQenterPipelineMode', 'libpq-fe.h' do |src| # since PostgreSQL-14
   # Ensure header files fit as well
   src + " int con(){ return PGRES_PIPELINE_SYNC; }"
 end
+have_func 'PQsetChunkedRowsMode', 'libpq-fe.h' # since PostgreSQL-17
 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
+have_func 'rb_io_descriptor' # since ruby-3.1
 
-# 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'
 have_header('ruby/fiber/scheduler.h') if RUBY_PLATFORM=~/mingw|mswin/
 

data/ext/gvl_wrappers.c

@@ -5,8 +5,19 @@
 
 #include "pg.h"
 
-#ifndef HAVE_PQENCRYPTPASSWORDCONN
-char *PQencryptPasswordConn(PGconn *conn, const char *passwd, const char *user, const char *algorithm){return NULL;}
+
+#ifndef HAVE_PQSETCHUNKEDROWSMODE
+PGresult *PQclosePrepared(PGconn *conn, const char *stmtName){return NULL;}
+PGresult *PQclosePortal(PGconn *conn, const char *portalName){return NULL;}
+int PQsendClosePrepared(PGconn *conn, const char *stmtName){return 0;}
+int PQsendClosePortal(PGconn *conn, const char *portalName){return 0;}
+int PQsendPipelineSync(PGconn *conn){return 0;}
+int PQcancelBlocking(PGcancelConn *cancelConn){return 0;}
+int PQcancelStart(PGcancelConn *cancelConn){return 0;}
+PostgresPollingStatusType PQcancelPoll(PGcancelConn *cancelConn){return PGRES_POLLING_FAILED;}
+#endif
+#ifndef HAVE_PQENTERPIPELINEMODE
+int PQpipelineSync(PGconn *conn){return 0;}
 #endif
 
 #ifdef ENABLE_GVL_UNLOCK

data/ext/gvl_wrappers.h

@@ -21,6 +21,10 @@
 #	include RUBY_EXTCONF_H
 #endif
 
+#ifndef HAVE_PQSETCHUNKEDROWSMODE
+typedef struct pg_cancel_conn PGcancelConn;
+#endif
+
 #define DEFINE_PARAM_LIST1(type, name) \
 	name,
 
@@ -149,6 +153,12 @@
 #define FOR_EACH_PARAM_OF_PQdescribePortal(param) \
 	param(PGconn *, conn)
 
+#define FOR_EACH_PARAM_OF_PQclosePrepared(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQclosePortal(param) \
+	param(PGconn *, conn)
+
 #define FOR_EACH_PARAM_OF_PQgetResult(param)
 
 #define FOR_EACH_PARAM_OF_PQputCopyData(param) \
@@ -196,11 +206,25 @@
 #define FOR_EACH_PARAM_OF_PQsendDescribePortal(param) \
 	param(PGconn *, conn)
 
+#define FOR_EACH_PARAM_OF_PQsendClosePrepared(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQsendClosePortal(param) \
+	param(PGconn *, conn)
+
+#define FOR_EACH_PARAM_OF_PQpipelineSync(param)
+
+#define FOR_EACH_PARAM_OF_PQsendPipelineSync(param)
+
 #define FOR_EACH_PARAM_OF_PQsetClientEncoding(param) \
 	param(PGconn *, conn)
 
 #define FOR_EACH_PARAM_OF_PQisBusy(param)
 
+#define FOR_EACH_PARAM_OF_PQcancelBlocking(param)
+#define FOR_EACH_PARAM_OF_PQcancelStart(param)
+#define FOR_EACH_PARAM_OF_PQcancelPoll(param)
+
 #define FOR_EACH_PARAM_OF_PQencryptPasswordConn(param) \
 	param(PGconn *, conn) \
 	param(const char *, passwd) \
@@ -225,6 +249,8 @@
 	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(PQclosePrepared, GVL_TYPE_NONVOID, PGresult *, const char *, stmtName) \
+	function(PQclosePortal, 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) \
@@ -236,8 +262,15 @@
 	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(PQsendClosePrepared, GVL_TYPE_NONVOID, int, const char *, stmt) \
+	function(PQsendClosePortal, GVL_TYPE_NONVOID, int, const char *, portal) \
+	function(PQpipelineSync, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQsendPipelineSync, GVL_TYPE_NONVOID, int, PGconn *, conn) \
 	function(PQsetClientEncoding, GVL_TYPE_NONVOID, int, const char *, encoding) \
 	function(PQisBusy, GVL_TYPE_NONVOID, int, PGconn *, conn) \
+	function(PQcancelBlocking, GVL_TYPE_NONVOID, int, PGcancelConn *, conn) \
+	function(PQcancelStart, GVL_TYPE_NONVOID, int, PGcancelConn *, conn) \
+	function(PQcancelPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGcancelConn *, conn) \
 	function(PQencryptPasswordConn, GVL_TYPE_NONVOID, char *, const char *, algorithm) \
 	function(PQcancel, GVL_TYPE_NONVOID, int, int, errbufsize);
 

data/ext/pg.c

@@ -404,6 +404,10 @@ Init_pg_ext(void)
 	/* Checking if server is in standby mode. Available since PostgreSQL-14. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_CHECK_STANDBY", INT2FIX(CONNECTION_CHECK_STANDBY));
 #endif
+#if PG_MAJORVERSION_NUM >= 17
+	/* Waiting for connection attempt to be started. Available since PostgreSQL-17. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_ALLOCATED", INT2FIX(CONNECTION_ALLOCATED));
+#endif
 
 	/******     PG::Connection CLASS CONSTANTS: Nonblocking connection polling status     ******/
 
@@ -451,14 +455,12 @@ Init_pg_ext(void)
 	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 ******/
 
@@ -506,6 +508,10 @@ Init_pg_ext(void)
 	rb_define_const(rb_mPGconstants, "PGRES_COPY_BOTH", INT2FIX(PGRES_COPY_BOTH));
 	/* Result#result_status constant - Single tuple from larger resultset. */
 	rb_define_const(rb_mPGconstants, "PGRES_SINGLE_TUPLE", INT2FIX(PGRES_SINGLE_TUPLE));
+#ifdef HAVE_PQSETCHUNKEDROWSMODE
+	/* Result#result_status constant - tuple chunk from larger resultset. */
+	rb_define_const(rb_mPGconstants, "PGRES_TUPLES_CHUNK", INT2FIX(PGRES_TUPLES_CHUNK));
+#endif
 
 #ifdef HAVE_PQENTERPIPELINEMODE
 	/* Result#result_status constant - The PG::Result represents a synchronization point in pipeline mode, requested by Connection#pipeline_sync.
@@ -530,20 +536,18 @@ Init_pg_ext(void)
 	 */
 	rb_define_const(rb_mPGconstants, "PG_DIAG_SEVERITY", INT2FIX(PG_DIAG_SEVERITY));
 
-#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 specific operations (such as error handling) in response to a particular database error.
+	 * The SQLSTATE code identifies the type of error that has occurred; it can be used by front-end applications to perform specific 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.
 	 */
@@ -667,6 +671,12 @@ Init_pg_ext(void)
 	/* PostgreSQL compiled in default port */
 	rb_define_const(rb_mPGconstants, "DEF_PGPORT", INT2FIX(DEF_PGPORT));
 
+#ifdef PG_IS_BINARY_GEM
+	rb_define_const(rb_mPG, "IS_BINARY_GEM", Qtrue);
+#else
+	rb_define_const(rb_mPG, "IS_BINARY_GEM", Qfalse);
+#endif
+
 	/* Add the constants to the toplevel namespace */
 	rb_include_module( rb_mPG, rb_mPGconstants );
 
@@ -689,4 +699,5 @@ Init_pg_ext(void)
 	init_pg_copycoder();
 	init_pg_recordcoder();
 	init_pg_tuple();
+	init_pg_cancon();
 }

data/ext/pg.h

@@ -76,14 +76,7 @@ typedef long suseconds_t;
 	#define PG_MAX_COLUMNS 4000
 #endif
 
-#ifdef HAVE_RB_GC_MARK_MOVABLE
-#define pg_compact_callback(x) (x)
 #define pg_gc_location(x) x = rb_gc_location(x)
-#else
-#define rb_gc_mark_movable(x) rb_gc_mark(x)
-#define pg_compact_callback(x) {(x)}
-#define pg_gc_location(x) UNUSED(x)
-#endif
 
 /* For compatibility with ruby < 3.0 */
 #ifndef RUBY_TYPED_FROZEN_SHAREABLE
@@ -123,10 +116,8 @@ typedef struct {
 	/* enable automatic flushing of send data at the end of send_query calls */
 	unsigned int flush_data : 1;
 
-#if defined(_WIN32)
 	/* File descriptor to be used for rb_w32_unwrap_io_handle() */
 	int ruby_sd;
-#endif
 } t_pg_connection;
 
 typedef struct pg_coder t_pg_coder;
@@ -215,6 +206,7 @@ typedef struct {
 	t_pg_coder comp;
 	t_pg_coder *elem;
 	int needs_quotation;
+	int dimensions;
 	char delimiter;
 } t_pg_composite_coder;
 
@@ -312,6 +304,7 @@ void init_pg_text_decoder                              _(( void ));
 void init_pg_binary_encoder                            _(( void ));
 void init_pg_binary_decoder                            _(( void ));
 void init_pg_tuple                                     _(( void ));
+void init_pg_cancon                                    _(( void ));
 VALUE lookup_error_class                               _(( const char * ));
 VALUE pg_bin_dec_bytea                                 _(( t_pg_coder*, const char *, int, int, int, int ));
 VALUE pg_text_dec_string                               _(( t_pg_coder*, const char *, int, int, int, int ));
@@ -351,6 +344,13 @@ void pg_typemap_compact                                _(( void * ));
 PGconn *pg_get_pgconn                                  _(( VALUE ));
 t_pg_connection *pg_get_connection                     _(( VALUE ));
 VALUE pgconn_block                                     _(( int, VALUE *, VALUE ));
+#ifdef __GNUC__
+__attribute__((format(printf, 3, 4)))
+#endif
+NORETURN(void pg_raise_conn_error                      _(( VALUE klass, VALUE self, const char *format, ...)));
+VALUE pg_wrap_socket_io                                _(( int sd, VALUE self, VALUE *p_socket_io, int *p_ruby_sd ));
+void pg_unwrap_socket_io                               _(( VALUE self, VALUE *p_socket_io, int ruby_sd ));
+
 
 VALUE pg_new_result                                    _(( PGresult *, VALUE ));
 VALUE pg_new_result_autoclear                          _(( PGresult *, VALUE ));

data/ext/pg_binary_decoder.c

@@ -133,6 +133,154 @@ pg_bin_dec_to_base64(t_pg_coder *conv, const char *val, int len, int tuple, int
 	return out_value;
 }
 
+/*
+ * Maximum number of array subscripts (arbitrary limit)
+ */
+#define MAXDIM 6
+
+/*
+ * Document-class: PG::BinaryDecoder::Array < PG::CompositeDecoder
+ *
+ * This is a decoder class for conversion of binary array types.
+ *
+ * It returns an Array with possibly an arbitrary number of sub-Arrays.
+ * All values are decoded according to the #elements_type accessor.
+ * Sub-arrays are decoded recursively.
+ *
+ * This decoder simply ignores any dimension decorations preceding the array values.
+ * It returns all array values as regular ruby Array with a zero based index, regardless of the index given in the dimension decoration.
+ *
+ * An array decoder which respects dimension decorations is waiting to be implemented.
+ *
+ */
+static VALUE
+pg_bin_dec_array(t_pg_coder *conv, const char *input_line, int len, int tuple, int field, int enc_idx)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, this->comp.format);
+
+	/* Current field */
+	VALUE field_str;
+
+	int32_t nitems32;
+	int i;
+	int ndim;
+	int nitems;
+	int flags;
+	int dim;
+	int dim_sizes[MAXDIM];
+	VALUE arrays[MAXDIM];
+	char *output_ptr;
+	const char *cur_ptr;
+	const char *line_end_ptr;
+	char *end_capa_ptr;
+
+	/* Allocate a new string with embedded capacity and realloc later with
+	 * exponential growing size when needed. */
+	PG_RB_STR_NEW( field_str, output_ptr, end_capa_ptr );
+
+	/* set pointer variables for loop */
+	cur_ptr = input_line;
+	line_end_ptr = input_line + len;
+
+	/* read number of dimensions */
+	if (line_end_ptr - cur_ptr < 4 ) goto length_error;
+	ndim = read_nbo32(cur_ptr);
+	if (ndim < 0 || ndim > MAXDIM) {
+		rb_raise( rb_eArgError, "unsupported number of array dimensions: %d", ndim );
+	}
+	cur_ptr += 4;
+
+	/* read flags */
+	if (line_end_ptr - cur_ptr < 4 ) goto length_error;
+	flags = read_nbo32(cur_ptr);
+	if (flags != 0 && flags != 1) {
+		rb_raise( rb_eArgError, "unsupported binary array flags: %d", flags );
+	}
+	cur_ptr += 4;
+
+	/* ignore element OID */
+	if (line_end_ptr - cur_ptr < 4 ) goto length_error;
+	cur_ptr += 4;
+
+	nitems32 = ndim == 0 ? 0 : 1;
+	for (i = 0; i < ndim; i++) {
+		int64_t prod;
+
+		/* read size of dimensions and ignore lower bound */
+		if (line_end_ptr - cur_ptr < 8 ) goto length_error;
+		dim_sizes[i] = read_nbo32(cur_ptr);
+		prod = (int64_t) nitems32 * (int64_t) dim_sizes[i];
+		nitems32 = (int32_t) prod;
+		if (dim_sizes[i] < 0 || (int64_t) nitems32 != prod) {
+			rb_raise( rb_eArgError, "unsupported array size: %" PRId64, prod );
+		}
+		cur_ptr += 8;
+	}
+	nitems = (int)nitems32;
+
+	dim = 0;
+	arrays[dim] = rb_ary_new2(ndim == 0 ? 0 : dim_sizes[dim]);
+	for (i = 0; i < nitems; i++) {
+		int input_len;
+
+		/* traverse dimensions down */
+		while (dim < ndim - 1) {
+			dim++;
+			arrays[dim] = rb_ary_new2(dim_sizes[dim]);
+			rb_ary_push(arrays[dim - 1], arrays[dim]);
+		}
+
+		/* read element length */
+		if (line_end_ptr - cur_ptr < 4 ) goto length_error;
+		input_len = read_nbo32(cur_ptr);
+		cur_ptr += 4;
+
+		/* convert and put element into array */
+		if (input_len < 0) {
+			if (input_len != -1) goto length_error;
+			/* NULL indicator */
+			rb_ary_push(arrays[dim], Qnil);
+		} else {
+			VALUE field_value;
+			if (line_end_ptr - cur_ptr < input_len ) goto length_error;
+
+			/* copy input data to field_str */
+			PG_RB_STR_ENSURE_CAPA( field_str, input_len, output_ptr, end_capa_ptr );
+			memcpy(output_ptr, cur_ptr, input_len);
+			cur_ptr += input_len;
+			output_ptr += input_len;
+			/* convert field_str through the type map */
+			rb_str_set_len( field_str, output_ptr - RSTRING_PTR(field_str) );
+			field_value = dec_func(this->elem, RSTRING_PTR(field_str), input_len, tuple, field, enc_idx);
+
+			rb_ary_push(arrays[dim], field_value);
+
+			if( field_value == field_str ){
+				/* Our output string will be send to the user, so we can not reuse
+				* it for the next field. */
+				PG_RB_STR_NEW( field_str, output_ptr, end_capa_ptr );
+			}
+		}
+
+		/* Reset the pointer to the start of the output/buffer string. */
+		output_ptr = RSTRING_PTR(field_str);
+
+		/* traverse dimensions up */
+		while (RARRAY_LEN(arrays[dim]) >= dim_sizes[dim] && dim > 0) {
+			dim--;
+		}
+	}
+
+	if (cur_ptr < line_end_ptr)
+		rb_raise( rb_eArgError, "trailing data after binary array data at position: %ld", (long)(cur_ptr - input_line) + 1 );
+
+	return arrays[0];
+
+length_error:
+	rb_raise( rb_eArgError, "premature end of binary array data at position: %ld", (long)(cur_ptr - input_line) + 1 );
+}
+
 #define PG_INT64_MIN	(-0x7FFFFFFFFFFFFFFFL - 1)
 #define PG_INT64_MAX	0x7FFFFFFFFFFFFFFFL
 
@@ -233,6 +381,8 @@ j2date(int jd, int *year, int *month, int *day)
  *
  * This is a decoder class for conversion of PostgreSQL binary date
  * to Ruby Date objects.
+ *
+ * As soon as this class is used, it requires the ruby standard library 'date'.
  */
 static VALUE
 pg_bin_dec_date(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
@@ -303,6 +453,8 @@ init_pg_binary_decoder(void)
 	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Timestamp", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Timestamp", pg_bin_dec_timestamp, rb_cPG_SimpleDecoder, rb_mPG_BinaryDecoder );
 
+	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Array", rb_cPG_CompositeDecoder ); */
+	pg_define_coder( "Array", pg_bin_dec_array, rb_cPG_CompositeDecoder, rb_mPG_BinaryDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "ToBase64", rb_cPG_CompositeDecoder ); */
 	pg_define_coder( "ToBase64", pg_bin_dec_to_base64, rb_cPG_CompositeDecoder, rb_mPG_BinaryDecoder );
 }