pg 1.5.9 → 1.7.0

data/ext/gvl_wrappers.h

@@ -15,12 +15,21 @@
 #ifndef __gvl_wrappers_h
 #define __gvl_wrappers_h
 
+#include <ruby/version.h>
 #include <ruby/thread.h>
 
 #ifdef RUBY_EXTCONF_H
 #	include RUBY_EXTCONF_H
 #endif
 
+#if RUBY_API_VERSION_MAJOR < 4
+extern int ruby_thread_has_gvl_p(void);
+#endif
+
+#ifndef LIBPQ_HAS_CHUNK_MODE
+typedef struct pg_cancel_conn PGcancelConn;
+#endif
+
 #define DEFINE_PARAM_LIST1(type, name) \
 	name,
 
@@ -79,20 +88,35 @@
 	}
 
 #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; ) \
-	}
+	#if RUBY_API_VERSION_MAJOR >= 4 || defined(TRUFFLERUBY)
+		#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){ \
+				struct gvl_wrapper_##name##_params params = { \
+					{FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname}, when_non_void((rettype)0) \
+				}; \
+				if (ruby_thread_has_gvl_p()) { \
+					gvl_##name##_skeleton(&params); \
+				} else { \
+					rb_thread_call_with_gvl(gvl_##name##_skeleton, &params); \
+				} \
+				when_non_void( return params.retval; ) \
+			}
+	#endif
 #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 ); \
-	}
+	#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)
@@ -101,145 +125,34 @@
 
 /*
  * Definitions of blocking functions and their parameters
+ *
+ * ATTENTION:
+ * Do not GVL-release functions that take pointers to ruby objects.
+ * If the ruby object is relocated by `GC.compact` from a second thread, before the pointer is used, it is no longer valid.
+ * That can lead to a crash or to wrong data.
+ * This issue has been raised in https://github.com/ged/ruby-pg/issues/738 and https://github.com/ged/ruby-pg/issues/721 .
  */
 
-#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)
+#define FOR_EACH_PARAM_OF_PQcancelStart(param)
+#define FOR_EACH_PARAM_OF_PQcancelPoll(param)
 
 /* 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);
+	function(PQcancelStart, GVL_TYPE_NONVOID, int, PGcancelConn *, conn) \
+	function(PQcancelPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGcancelConn *, conn) \
 
 FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB_DECL );
 

data/ext/pg.c

@@ -212,10 +212,10 @@ pg_get_rb_encoding_as_pg_encoding( rb_encoding *enc )
  *
  */
 char *
-pg_rb_str_ensure_capa( VALUE str, long expand_len, char *curr_ptr, char **end_ptr )
+pg_rb_str_ensure_capa( VALUE str, size_t expand_len, char *curr_ptr, char **end_ptr )
 {
-	long curr_len = curr_ptr - RSTRING_PTR(str);
-	long curr_capa = rb_str_capacity( str );
+	size_t curr_len = curr_ptr - RSTRING_PTR(str);
+	size_t 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 );
@@ -384,14 +384,10 @@ Init_pg_ext(void)
 	rb_define_const(rb_mPGconstants, "CONNECTION_SSL_STARTUP", INT2FIX(CONNECTION_SSL_STARTUP));
 	/* Internal state - PG.connect() needed. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_NEEDED", INT2FIX(CONNECTION_NEEDED));
-#if PG_MAJORVERSION_NUM >= 10
-	/* Checking if session is read-write. Available since PostgreSQL-10. */
+	/* Checking if session is read-write. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_CHECK_WRITABLE", INT2FIX(CONNECTION_CHECK_WRITABLE));
-#endif
-#if PG_MAJORVERSION_NUM >= 10
-	/* Consuming any extra messages. Available since PostgreSQL-10. */
+	/* Consuming any extra messages. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_CONSUME", INT2FIX(CONNECTION_CONSUME));
-#endif
 #if PG_MAJORVERSION_NUM >= 12
 	/* Negotiating GSSAPI. Available since PostgreSQL-12. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_GSS_STARTUP", INT2FIX(CONNECTION_GSS_STARTUP));
@@ -404,6 +400,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 +451,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,8 +504,12 @@ 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 LIBPQ_HAS_CHUNK_MODE
+	/* 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
+#ifdef LIBPQ_HAS_PIPELINING
 	/* Result#result_status constant - The PG::Result represents a synchronization point in pipeline mode, requested by Connection#pipeline_sync.
 	 *
 	 * This status occurs only when pipeline mode has been selected. */
@@ -530,16 +532,14 @@ 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.
@@ -639,7 +639,7 @@ Init_pg_ext(void)
 	rb_define_const(rb_mPGconstants, "PG_DIAG_CONSTRAINT_NAME", INT2FIX(PG_DIAG_CONSTRAINT_NAME));
 #endif
 
-#ifdef HAVE_PQENTERPIPELINEMODE
+#ifdef LIBPQ_HAS_PIPELINING
 	/* Connection#pipeline_status constant
 	 *
 	 * The libpq connection is in pipeline mode.
@@ -667,6 +667,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 +695,5 @@ Init_pg_ext(void)
 	init_pg_copycoder();
 	init_pg_recordcoder();
 	init_pg_tuple();
+	init_pg_cancon();
 }

data/ext/pg.h

@@ -76,21 +76,14 @@ 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)
+#ifndef HAVE_RB_HASH_NEW_CAPA
+#define rb_hash_new_capa(x) rb_hash_new()
 #endif
 
-/* For compatibility with ruby < 3.0 */
-#ifndef RUBY_TYPED_FROZEN_SHAREABLE
-#define PG_RUBY_TYPED_FROZEN_SHAREABLE 0
-#else
-#define PG_RUBY_TYPED_FROZEN_SHAREABLE RUBY_TYPED_FROZEN_SHAREABLE
-#endif
+#define pg_gc_location(x) x = rb_gc_location(x)
+
+extern int ruby_native_thread_p(void);
+
 #define PG_ENC_IDX_BITS 28
 
 /* The data behind each PG::Connection object */
@@ -106,6 +99,8 @@ typedef struct {
 	VALUE notice_receiver;
 	/* Proc object that receives notices as String objects */
 	VALUE notice_processor;
+	/* Corresponding PG::Connection ruby object. Only used for the notice_receiver */
+	VALUE self;
 	/* Kind of PG::TypeMap object for casting query params */
 	VALUE type_map_for_queries;
 	/* Kind of PG::TypeMap object for casting result values */
@@ -119,14 +114,12 @@ typedef struct {
 	/* Ruby encoding index of the client/internal encoding */
 	int enc_idx : PG_ENC_IDX_BITS;
 	/* flags controlling Symbol/String field names */
-	unsigned int flags : 2;
+	unsigned int flags : 1;
 	/* 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;
@@ -156,7 +149,7 @@ typedef struct {
 	unsigned int autoclear : 1;
 
 	/* flags controlling Symbol/String field names */
-	unsigned int flags : 2;
+	unsigned int flags : 1;
 
 	/* Number of fields in fnames[] .
 	 * Set to -1 if fnames[] is not yet initialized.
@@ -166,10 +159,8 @@ typedef struct {
 	/* Size of PGresult as published to ruby memory management. */
 	ssize_t result_size;
 
-	/* Prefilled tuple Hash with fnames[] as keys. */
-	VALUE tuple_hash;
-
-	/* Hash with fnames[] to field number mapping. */
+	/* Hash with fnames[] to field number mapping.
+	 * Init on-demand to create PG::Tuple objects, otherwise Qnil. */
 	VALUE field_map;
 
 	/* List of field names as frozen String or Symbol objects.
@@ -188,9 +179,8 @@ typedef VALUE (* t_pg_typecast_result)(t_typemap *, VALUE, int, int);
 typedef t_pg_coder *(* t_pg_typecast_query_param)(t_typemap *, VALUE, int);
 typedef VALUE (* t_pg_typecast_copy_get)( t_typemap *, VALUE, int, int, int );
 
-#define PG_RESULT_FIELD_NAMES_MASK 0x03
+#define PG_RESULT_FIELD_NAMES_MASK 0x01
 #define PG_RESULT_FIELD_NAMES_SYMBOL 0x01
-#define PG_RESULT_FIELD_NAMES_STATIC_SYMBOL 0x02
 
 #define PG_CODER_TIMESTAMP_DB_UTC 0x0
 #define PG_CODER_TIMESTAMP_DB_LOCAL 0x1
@@ -215,6 +205,7 @@ typedef struct {
 	t_pg_coder comp;
 	t_pg_coder *elem;
 	int needs_quotation;
+	int dimensions;
 	char delimiter;
 } t_pg_composite_coder;
 
@@ -312,6 +303,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 ));
@@ -325,7 +317,7 @@ VALUE pg_tmbc_allocate                                 _(( void ));
 void pg_coder_init_encoder                             _(( VALUE ));
 void pg_coder_init_decoder                             _(( VALUE ));
 void pg_coder_compact                                  _(( void * ));
-char *pg_rb_str_ensure_capa                            _(( VALUE, long, char *, char ** ));
+char *pg_rb_str_ensure_capa                            _(( VALUE, size_t, char *, char ** ));
 
 #define PG_RB_STR_ENSURE_CAPA( str, expand_len, curr_ptr, end_ptr ) \
 	do { \
@@ -351,6 +343,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

@@ -13,6 +13,7 @@
 
 VALUE rb_mPG_BinaryDecoder;
 static VALUE s_Date;
+static VALUE s_Date_GREGORIAN; /* Date::GREGORIAN */
 static ID s_id_new;
 
 
@@ -117,7 +118,7 @@ pg_bin_dec_to_base64(t_pg_coder *conv, const char *val, int len, int tuple, int
 	/* create a buffer of the encoded length */
 	VALUE out_value = rb_str_new(NULL, encoded_len);
 
-	base64_encode( RSTRING_PTR(out_value), val, len );
+	rbpg_base64_encode( RSTRING_PTR(out_value), val, len );
 
 	/* Is it a pure String conversion? Then we can directly send out_value to the user. */
 	if( this->comp.format == 0 && dec_func == pg_text_dec_string ){
@@ -133,6 +134,155 @@ 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;
+	if (nitems > (line_end_ptr - cur_ptr) / 4) goto length_error;
+
+	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
 
@@ -255,7 +405,7 @@ pg_bin_dec_date(t_pg_coder *conv, const char *val, int len, int tuple, int field
 		default:
 			j2date(date + POSTGRES_EPOCH_JDATE, &year, &month, &day);
 
-			return rb_funcall(s_Date, s_id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+			return rb_funcall(s_Date, s_id_new, 4, INT2NUM(year), INT2NUM(month), INT2NUM(day), s_Date_GREGORIAN);
 	}
 }
 
@@ -264,8 +414,10 @@ static VALUE
 init_pg_bin_decoder_date(VALUE rb_mPG_BinaryDecoder)
 {
 	rb_require("date");
+	rb_gc_register_address(&s_Date);
+	rb_gc_register_address(&s_Date_GREGORIAN);
 	s_Date = rb_const_get(rb_cObject, rb_intern("Date"));
-	rb_gc_register_mark_object(s_Date);
+	s_Date_GREGORIAN = rb_const_get(s_Date, rb_intern("GREGORIAN"));
 	s_id_new = rb_intern("new");
 
 	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Date", rb_cPG_SimpleDecoder ); */
@@ -305,6 +457,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 );
 }