pg 1.4.6 → 1.6.0

data/ext/pg.c

@@ -33,7 +33,6 @@
  *
  * - PQfreemem -- unnecessary: copied to ruby object, then freed. Ruby object's
  *                memory is freed when it is garbage collected.
- * - PQbinaryTuples -- better to use PQfformat
  * - PQprint -- not very useful
  * - PQsetdb -- not very useful
  * - PQoidStatus -- deprecated, use PQoidValue
@@ -74,6 +73,7 @@ VALUE rb_mPGconstants;
  * The mapping from canonical encoding names in PostgreSQL to ones in Ruby.
  */
 const char * const (pg_enc_pg2ruby_mapping[][2]) = {
+	{"UTF8",          "UTF-8"       },
 	{"BIG5",          "Big5"        },
 	{"EUC_CN",        "GB2312"      },
 	{"EUC_JP",        "EUC-JP"      },
@@ -105,7 +105,6 @@ const char * const (pg_enc_pg2ruby_mapping[][2]) = {
 	{"SHIFT_JIS_2004","Windows-31J" },
 	/* {"SQL_ASCII",     NULL          },  special case*/
 	{"UHC",           "CP949"       },
-	{"UTF8",          "UTF-8"       },
 	{"WIN866",        "IBM866"      },
 	{"WIN874",        "Windows-874" },
 	{"WIN1250",       "Windows-1250"},
@@ -120,36 +119,17 @@ 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;
-
-
 /*
  * Return the given PostgreSQL encoding ID as an rb_encoding.
  *
  * - returns NULL if the client encoding is 'SQL_ASCII'.
  * - returns ASCII-8BIT if the client encoding is unknown.
  */
-rb_encoding *
+static rb_encoding *
 pg_get_pg_encoding_as_rb_encoding( int enc_id )
 {
-	rb_encoding *enc;
-
-	/* Use the cached value if it exists */
-	if ( st_lookup(enc_pg2ruby, (st_data_t)enc_id, (st_data_t*)&enc) ) {
-		return enc;
-	}
-	else {
-		const char *name = pg_encoding_to_char( enc_id );
-
-		enc = pg_get_pg_encname_as_rb_encoding( name );
-		st_insert( enc_pg2ruby, (st_data_t)enc_id, (st_data_t)enc );
-
-		return enc;
-	}
-
+	const char *name = pg_encoding_to_char( enc_id );
+	return pg_get_pg_encname_as_rb_encoding( name );
 }
 
 /*
@@ -354,6 +334,11 @@ pg_s_init_ssl(VALUE self, VALUE do_ssl)
 void
 Init_pg_ext(void)
 {
+
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+	rb_ext_ractor_safe(PQisthreadsafe());
+#endif
+
 	if( RTEST(rb_eval_string("ENV['PG_SKIP_DEPRECATION_WARNING']")) ){
 		/* Set all bits to disable all deprecation warnings. */
 		pg_skip_deprecation_warning = 0xFFFF;
@@ -372,8 +357,8 @@ Init_pg_ext(void)
 	SINGLETON_ALIAS( rb_mPG, "is_threadsafe?", "isthreadsafe" );
 	SINGLETON_ALIAS( rb_mPG, "threadsafe?", "isthreadsafe" );
 
-  rb_define_singleton_method( rb_mPG, "init_openssl", pg_s_init_openssl, 2 );
-  rb_define_singleton_method( rb_mPG, "init_ssl", pg_s_init_ssl, 1 );
+	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     ******/
@@ -419,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     ******/
 
@@ -466,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 ******/
 
@@ -521,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.
@@ -545,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.
 	 */
@@ -682,11 +671,15 @@ 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 );
 
-	enc_pg2ruby = st_init_numtable();
-
 	/* Initialize the main extension classes */
 	init_pg_connection();
 	init_pg_result();
@@ -706,5 +699,5 @@ Init_pg_ext(void)
 	init_pg_copycoder();
 	init_pg_recordcoder();
 	init_pg_tuple();
+	init_pg_cancon();
 }
-

data/ext/pg.h

@@ -76,19 +76,14 @@ typedef long suseconds_t;
 	#define PG_MAX_COLUMNS 4000
 #endif
 
-#ifndef RARRAY_AREF
-#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
-#endif
-
-#ifdef HAVE_RB_GC_MARK_MOVABLE
-#define pg_compact_callback(x) (x)
 #define pg_gc_location(x) x = rb_gc_location(x)
+
+/* For compatibility with ruby < 3.0 */
+#ifndef RUBY_TYPED_FROZEN_SHAREABLE
+#define PG_RUBY_TYPED_FROZEN_SHAREABLE 0
 #else
-#define rb_gc_mark_movable(x) rb_gc_mark(x)
-#define pg_compact_callback(x) {(x)}
-#define pg_gc_location(x) UNUSED(x)
+#define PG_RUBY_TYPED_FROZEN_SHAREABLE RUBY_TYPED_FROZEN_SHAREABLE
 #endif
-
 #define PG_ENC_IDX_BITS 28
 
 /* The data behind each PG::Connection object */
@@ -97,6 +92,9 @@ typedef struct {
 
 	/* Cached IO object for the socket descriptor */
 	VALUE socket_io;
+	/* function pointers of the original libpq notice receivers */
+	PQnoticeReceiver default_notice_receiver;
+	PQnoticeProcessor default_notice_processor;
 	/* Proc object that receives notices as PG::Result objects */
 	VALUE notice_receiver;
 	/* Proc object that receives notices as String objects */
@@ -118,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;
@@ -210,6 +206,7 @@ typedef struct {
 	t_pg_coder comp;
 	t_pg_coder *elem;
 	int needs_quotation;
+	int dimensions;
 	char delimiter;
 } t_pg_composite_coder;
 
@@ -307,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 ));
@@ -314,7 +312,7 @@ int pg_coder_enc_to_s                                  _(( t_pg_coder*, VALUE, c
 int pg_text_enc_identifier                             _(( t_pg_coder*, VALUE, char *, VALUE *, int));
 t_pg_coder_enc_func pg_coder_enc_func                  _(( t_pg_coder* ));
 t_pg_coder_dec_func pg_coder_dec_func                  _(( t_pg_coder*, int ));
-void pg_define_coder                                   _(( const char *, void *, VALUE, VALUE ));
+VALUE pg_define_coder                                  _(( const char *, void *, VALUE, VALUE ));
 VALUE pg_obj_to_i                                      _(( VALUE ));
 VALUE pg_tmbc_allocate                                 _(( void ));
 void pg_coder_init_encoder                             _(( VALUE ));
@@ -346,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 ));
@@ -364,7 +369,6 @@ pgresult_get_this( VALUE self )
 }
 
 
-rb_encoding * pg_get_pg_encoding_as_rb_encoding        _(( int ));
 rb_encoding * pg_get_pg_encname_as_rb_encoding         _(( const char * ));
 const char * pg_get_rb_encoding_as_pg_encoding         _(( rb_encoding * ));
 rb_encoding *pg_conn_enc_get                           _(( PGconn * ));

data/ext/pg_binary_decoder.c

@@ -12,6 +12,8 @@
 #endif
 
 VALUE rb_mPG_BinaryDecoder;
+static VALUE s_Date;
+static ID s_id_new;
 
 
 /*
@@ -131,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
 
@@ -195,6 +345,84 @@ pg_bin_dec_timestamp(t_pg_coder *conv, const char *val, int len, int tuple, int
 	}
 }
 
+#define PG_INT32_MIN    (-0x7FFFFFFF-1)
+#define PG_INT32_MAX    (0x7FFFFFFF)
+#define POSTGRES_EPOCH_JDATE   2451545 /* == date2j(2000, 1, 1) */
+#define MONTHS_PER_YEAR 12
+
+/* taken from PostgreSQL sources at src/backend/utils/adt/datetime.c */
+void
+j2date(int jd, int *year, int *month, int *day)
+{
+	unsigned int julian;
+	unsigned int quad;
+	unsigned int extra;
+	int			y;
+
+	julian = jd;
+	julian += 32044;
+	quad = julian / 146097;
+	extra = (julian - quad * 146097) * 4 + 3;
+	julian += 60 + quad * 3 + extra / 146097;
+	quad = julian / 1461;
+	julian -= quad * 1461;
+	y = julian * 4 / 1461;
+	julian = ((y != 0) ? ((julian + 305) % 365) : ((julian + 306) % 366))
+		+ 123;
+	y += quad * 4;
+	*year = y - 4800;
+	quad = julian * 2141 / 65536;
+	*day = julian - 7834 * quad / 256;
+	*month = (quad + 10) % MONTHS_PER_YEAR + 1;
+}								/* j2date() */
+
+/*
+ * Document-class: PG::BinaryDecoder::Date < PG::SimpleDecoder
+ *
+ * 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)
+{
+	int year, month, day;
+	int date;
+
+	if (len != 4) {
+		rb_raise(rb_eTypeError, "unexpected date format != 4 bytes");
+	}
+
+	date = read_nbo32(val);
+	switch(date){
+		case PG_INT32_MAX:
+			return rb_str_new2("infinity");
+		case PG_INT32_MIN:
+			return rb_str_new2("-infinity");
+		default:
+			j2date(date + POSTGRES_EPOCH_JDATE, &year, &month, &day);
+
+			return rb_funcall(s_Date, s_id_new, 3, INT2NUM(year), INT2NUM(month), INT2NUM(day));
+	}
+}
+
+/* called per autoload when BinaryDecoder::Date is used */
+static VALUE
+init_pg_bin_decoder_date(VALUE rb_mPG_BinaryDecoder)
+{
+	rb_require("date");
+	s_Date = rb_const_get(rb_cObject, rb_intern("Date"));
+	rb_gc_register_mark_object(s_Date);
+	s_id_new = rb_intern("new");
+
+	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Date", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Date", pg_bin_dec_date, rb_cPG_SimpleDecoder, rb_mPG_BinaryDecoder );
+
+	return Qnil;
+}
+
+
 /*
  * Document-class: PG::BinaryDecoder::String < PG::SimpleDecoder
  *
@@ -209,6 +437,7 @@ init_pg_binary_decoder(void)
 {
 	/* This module encapsulates all decoder classes with binary input format */
 	rb_mPG_BinaryDecoder = rb_define_module_under( rb_mPG, "BinaryDecoder" );
+	rb_define_private_method(rb_singleton_class(rb_mPG_BinaryDecoder), "init_date", init_pg_bin_decoder_date, 0);
 
 	/* Make RDoc aware of the decoder classes... */
 	/* dummy = rb_define_class_under( rb_mPG_BinaryDecoder, "Boolean", rb_cPG_SimpleDecoder ); */
@@ -224,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 );
 }