pg 1.4.4 → 1.5.3

data/certs/larskanis-2023.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEBDCCAmygAwIBAgIBAjANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yMzAyMTUxNzQxMTVaFw0yNDAy
+MTUxNzQxMTVaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjOTA3MAkG
+A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ4h1tIyvdUWtMI739xMzTR
+7EfMFzANBgkqhkiG9w0BAQsFAAOCAYEAQAcuTARfiiVUVx5KURICfdTM2Kd7LhOn
+qt3Vs4ANGvT226LEp3RnQ+kWGQYMRb3cw3LY2TNQRPlnZxE994mgjBscN4fbjXqO
+T0JbVpeszRZa5k1goggbnWT7CO7yU7WcHh13DaSubY7HUpAJn2xz9w2stxQfN/EE
+VMlnDJ1P7mUHAvpK8X9j9h7Xlc1niViT18MYwux8mboVTryrLr+clATUkkM3yBF0
+RV+c34ReW5eXO9Tr6aKTxh/pFC9ggDT6jOxuJgSvG8HWJzVf4NDvMavIas4KYjiI
+BU6CpWaG5NxicqL3BERi52U43HV08br+LNVpb7Rekgve/PJuSFnAR015bhSRXe5U
+vBioD1qW2ZW9tXg8Ww2IfDaO5a1So5Xby51rhNlyo6ATj2NkuLWZUKPKHhAz0TKm
+Dzx/gFSOrRoCt2mXNgrmcAfr386AfaMvCh7cXqdxZwmVo7ILZCYXck0pajvubsDd
+NUIIFkVXvd1odFyK9LF1RFAtxn/iAmpx
+-----END CERTIFICATE-----

data/ext/errorcodes.def

@@ -366,6 +366,10 @@
   VALUE klass = define_error_class( "SqlJsonScalarRequired", "22" );
   register_error_class( "2203F", klass );
 }
+{
+  VALUE klass = define_error_class( "SqlJsonItemCannotBeCastToTargetType", "22" );
+  register_error_class( "2203G", klass );
+}
 {
   VALUE klass = define_error_class( "IntegrityConstraintViolation", NULL );
   register_error_class( "23000", klass );

data/ext/errorcodes.txt

@@ -2,7 +2,7 @@
 # errcodes.txt
 #      PostgreSQL error codes
 #
-# Copyright (c) 2003-2021, PostgreSQL Global Development Group
+# Copyright (c) 2003-2022, PostgreSQL Global Development Group
 #
 # This list serves as the basis for generating source files containing error
 # codes. It is kept in a common format to make sure all these source files have
@@ -222,6 +222,7 @@ Section: Class 22 - Data Exception
 2203D    E    ERRCODE_TOO_MANY_JSON_ARRAY_ELEMENTS                           too_many_json_array_elements
 2203E    E    ERRCODE_TOO_MANY_JSON_OBJECT_MEMBERS                           too_many_json_object_members
 2203F    E    ERRCODE_SQL_JSON_SCALAR_REQUIRED                               sql_json_scalar_required
+2203G    E    ERRCODE_SQL_JSON_ITEM_CANNOT_BE_CAST_TO_TARGET_TYPE            sql_json_item_cannot_be_cast_to_target_type
 
 Section: Class 23 - Integrity Constraint Violation
 

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,12 +119,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;
-
-
 /*
  * Return the given PostgreSQL encoding ID as an rb_encoding.
  *
@@ -135,21 +128,8 @@ static struct st_table *enc_pg2ruby;
 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     ******/
@@ -679,11 +664,12 @@ Init_pg_ext(void)
 	rb_define_const(rb_mPGconstants, "INVALID_OID", INT2FIX(InvalidOid));
 	rb_define_const(rb_mPGconstants, "InvalidOid", INT2FIX(InvalidOid));
 
+	/* PostgreSQL compiled in default port */
+	rb_define_const(rb_mPGconstants, "DEF_PGPORT", INT2FIX(DEF_PGPORT));
+
 	/* 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();
@@ -704,4 +690,3 @@ Init_pg_ext(void)
 	init_pg_recordcoder();
 	init_pg_tuple();
 }
-

data/ext/pg.h

@@ -76,10 +76,6 @@ 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)
@@ -89,6 +85,12 @@ typedef long suseconds_t;
 #define pg_gc_location(x) UNUSED(x)
 #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_ENC_IDX_BITS 28
 
 /* The data behind each PG::Connection object */
@@ -97,6 +99,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 */
@@ -314,7 +319,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 ));

data/ext/pg_binary_decoder.c

@@ -12,6 +12,8 @@
 #endif
 
 VALUE rb_mPG_BinaryDecoder;
+static VALUE s_Date;
+static ID s_id_new;
 
 
 /*
@@ -195,6 +197,82 @@ 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.
+ */
+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 +287,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 ); */

data/ext/pg_binary_encoder.c

@@ -11,6 +11,9 @@
 #endif
 
 VALUE rb_mPG_BinaryEncoder;
+static ID s_id_year;
+static ID s_id_month;
+static ID s_id_day;
 
 
 /*
@@ -93,6 +96,215 @@ pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, i
 	return 8;
 }
 
+/*
+ * Document-class: PG::BinaryEncoder::Float4 < PG::SimpleEncoder
+ *
+ * This is the binary encoder class for the PostgreSQL +float4+ type.
+ *
+ */
+static int
+pg_bin_enc_float4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
+{
+	union {
+		float f;
+		int32_t i;
+	} swap4;
+
+	if(out){
+		swap4.f = NUM2DBL(*intermediate);
+		write_nbo32(swap4.i, out);
+	}else{
+		*intermediate = value;
+	}
+	return 4;
+}
+
+/*
+ * Document-class: PG::BinaryEncoder::Float8 < PG::SimpleEncoder
+ *
+ * This is the binary encoder class for the PostgreSQL +float8+ type.
+ *
+ */
+static int
+pg_bin_enc_float8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
+{
+	union {
+		double f;
+		int64_t i;
+	} swap8;
+
+	if(out){
+		swap8.f = NUM2DBL(*intermediate);
+		write_nbo64(swap8.i, out);
+	}else{
+		*intermediate = value;
+	}
+	return 8;
+}
+
+#define PG_INT32_MIN    (-0x7FFFFFFF-1)
+#define PG_INT32_MAX    (0x7FFFFFFF)
+#define PG_INT64_MIN	(-0x7FFFFFFFFFFFFFFFL - 1)
+#define PG_INT64_MAX	0x7FFFFFFFFFFFFFFFL
+
+/*
+ * Document-class: PG::BinaryEncoder::Timestamp < PG::SimpleEncoder
+ *
+ * This is a encoder class for conversion of Ruby Time objects to PostgreSQL binary timestamps.
+ *
+ * The following flags can be used to specify timezone interpretation:
+ * * +PG::Coder::TIMESTAMP_DB_UTC+ : Send timestamp as UTC time (default)
+ * * +PG::Coder::TIMESTAMP_DB_LOCAL+ : Send timestamp as local time (slower)
+ *
+ * Example:
+ *   enco = PG::BinaryEncoder::Timestamp.new(flags: PG::Coder::TIMESTAMP_DB_UTC)
+ *   enco.encode(Time.utc(2000, 1, 1))  # => "\x00\x00\x00\x00\x00\x00\x00\x00"
+ *
+ * String values are expected to contain a binary data with a length of 8 byte.
+ *
+ */
+static int
+pg_bin_enc_timestamp(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
+{
+	if(out){
+		int64_t timestamp;
+		struct timespec ts;
+
+		/* second call -> write data to *out */
+		switch(TYPE(*intermediate)){
+			case T_STRING:
+				return pg_coder_enc_to_s(this, value, out, intermediate, enc_idx);
+			case T_TRUE:
+				write_nbo64(PG_INT64_MAX, out);
+				return 8;
+			case T_FALSE:
+				write_nbo64(PG_INT64_MIN, out);
+				return 8;
+		}
+
+		ts = rb_time_timespec(*intermediate);
+		/* PostgreSQL's timestamp is based on year 2000 and Ruby's time is based on 1970.
+			* Adjust the 30 years difference. */
+		timestamp = (ts.tv_sec - 10957L * 24L * 3600L) * 1000000 + (ts.tv_nsec / 1000);
+
+		if( this->flags & PG_CODER_TIMESTAMP_DB_LOCAL ) {
+			/* send as local time */
+			timestamp += NUM2LL(rb_funcall(*intermediate, rb_intern("utc_offset"), 0)) * 1000000;
+		}
+
+		write_nbo64(timestamp, out);
+	}else{
+		/* first call -> determine the required length */
+		if(TYPE(value) == T_STRING){
+			char *pstr = RSTRING_PTR(value);
+			if(RSTRING_LEN(value) >= 1){
+				switch(pstr[0]) {
+					case 'I':
+					case 'i':
+						*intermediate = Qtrue;
+						return 8;
+					case '-':
+						if (RSTRING_LEN(value) >= 2 && (pstr[1] == 'I' || pstr[1] == 'i')) {
+							*intermediate = Qfalse;
+							return 8;
+						}
+				}
+			}
+
+			return pg_coder_enc_to_s(this, value, out, intermediate, enc_idx);
+		}
+
+		if( this->flags & PG_CODER_TIMESTAMP_DB_LOCAL ) {
+			/* make a local time, so that utc_offset is set */
+			value = rb_funcall(value, rb_intern("getlocal"), 0);
+		}
+		*intermediate = value;
+	}
+	return 8;
+}
+
+#define POSTGRES_EPOCH_JDATE   2451545 /* == date2j(2000, 1, 1) */
+int
+date2j(int year, int month, int day)
+{
+	int			julian;
+	int			century;
+
+	if (month > 2)
+	{
+		month += 1;
+		year += 4800;
+	}
+	else
+	{
+		month += 13;
+		year += 4799;
+	}
+
+	century = year / 100;
+	julian = year * 365 - 32167;
+	julian += year / 4 - century + century / 4;
+	julian += 7834 * month / 256 + day;
+
+	return julian;
+}								/* date2j() */
+
+/*
+ * Document-class: PG::BinaryEncoder::Date < PG::SimpleEncoder
+ *
+ * This is a encoder class for conversion of Ruby Date objects to PostgreSQL binary date.
+ *
+ * String values are expected to contain a binary data with a length of 4 byte.
+ *
+ */
+static int
+pg_bin_enc_date(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
+{
+	if(out){
+		/* second call -> write data to *out */
+		switch(TYPE(*intermediate)){
+			case T_STRING:
+				return pg_coder_enc_to_s(this, value, out, intermediate, enc_idx);
+			case T_TRUE:
+				write_nbo32(PG_INT32_MAX, out);
+				return 4;
+			case T_FALSE:
+				write_nbo32(PG_INT32_MIN, out);
+				return 4;
+		}
+
+		VALUE year = rb_funcall(value, s_id_year, 0);
+		VALUE month = rb_funcall(value, s_id_month, 0);
+		VALUE day = rb_funcall(value, s_id_day, 0);
+		int jday = date2j(NUM2INT(year), NUM2INT(month), NUM2INT(day)) - POSTGRES_EPOCH_JDATE;
+		write_nbo32(jday, out);
+
+	}else{
+		/* first call -> determine the required length */
+		if(TYPE(value) == T_STRING){
+			char *pstr = RSTRING_PTR(value);
+			if(RSTRING_LEN(value) >= 1){
+				switch(pstr[0]) {
+					case 'I':
+					case 'i':
+						*intermediate = Qtrue;
+						return 4;
+					case '-':
+						if (RSTRING_LEN(value) >= 2 && (pstr[1] == 'I' || pstr[1] == 'i')) {
+							*intermediate = Qfalse;
+							return 4;
+						}
+				}
+			}
+
+			return pg_coder_enc_to_s(this, value, out, intermediate, enc_idx);
+		}
+
+		*intermediate = value;
+	}
+	return 4;
+}
+
 /*
  * Document-class: PG::BinaryEncoder::FromBase64 < PG::CompositeEncoder
  *
@@ -141,6 +353,10 @@ pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermed
 void
 init_pg_binary_encoder(void)
 {
+	s_id_year = rb_intern("year");
+	s_id_month = rb_intern("month");
+	s_id_day = rb_intern("day");
+
 	/* This module encapsulates all encoder classes with binary output format */
 	rb_mPG_BinaryEncoder = rb_define_module_under( rb_mPG, "BinaryEncoder" );
 
@@ -153,10 +369,18 @@ init_pg_binary_encoder(void)
 	pg_define_coder( "Int4", pg_bin_enc_int4, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "Int8", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "Int8", pg_bin_enc_int8, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "Float4", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Float4", pg_bin_enc_float4, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "Float8", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Float8", pg_bin_enc_float8, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "String", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "String", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "Bytea", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "Bytea", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "Timestamp", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Timestamp", pg_bin_enc_timestamp, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "Date", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Date", pg_bin_enc_date, rb_cPG_SimpleEncoder, rb_mPG_BinaryEncoder );
 
 	/* dummy = rb_define_class_under( rb_mPG_BinaryEncoder, "FromBase64", rb_cPG_CompositeEncoder ); */
 	pg_define_coder( "FromBase64", pg_bin_enc_from_base64, rb_cPG_CompositeEncoder, rb_mPG_BinaryEncoder );

data/ext/pg_coder.c

@@ -35,7 +35,7 @@ pg_coder_init_encoder( VALUE self )
 		this->enc_func = NULL;
 	}
 	this->dec_func = NULL;
-	this->coder_obj = self;
+	RB_OBJ_WRITE(self, &this->coder_obj, self);
 	this->oid = 0;
 	this->format = 0;
 	this->flags = 0;
@@ -54,7 +54,7 @@ pg_coder_init_decoder( VALUE self )
 	} else {
 		this->dec_func = NULL;
 	}
-	this->coder_obj = self;
+	RB_OBJ_WRITE(self, &this->coder_obj, self);
 	this->oid = 0;
 	this->format = 0;
 	this->flags = 0;
@@ -99,7 +99,9 @@ const rb_data_type_t pg_coder_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	// IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+	// macro to update VALUE references, as to trigger write barriers.
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -121,7 +123,7 @@ static const rb_data_type_t pg_composite_coder_type = {
 	},
 	&pg_coder_type,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
 static VALUE
@@ -273,6 +275,7 @@ static VALUE
 pg_coder_oid_set(VALUE self, VALUE oid)
 {
 	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->oid = NUM2UINT(oid);
 	return oid;
 }
@@ -304,6 +307,7 @@ static VALUE
 pg_coder_format_set(VALUE self, VALUE format)
 {
 	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->format = NUM2INT(format);
 	return format;
 }
@@ -335,6 +339,7 @@ static VALUE
 pg_coder_flags_set(VALUE self, VALUE flags)
 {
 	t_pg_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->flags = NUM2INT(flags);
 	return flags;
 }
@@ -366,6 +371,7 @@ static VALUE
 pg_coder_needs_quotation_set(VALUE self, VALUE needs_quotation)
 {
 	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	this->needs_quotation = RTEST(needs_quotation);
 	return needs_quotation;
 }
@@ -396,6 +402,7 @@ static VALUE
 pg_coder_delimiter_set(VALUE self, VALUE delimiter)
 {
 	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
+	rb_check_frozen(self);
 	StringValue(delimiter);
 	if(RSTRING_LEN(delimiter) != 1)
 		rb_raise( rb_eArgError, "delimiter size must be one byte");
@@ -430,6 +437,7 @@ pg_coder_elements_type_set(VALUE self, VALUE elem_type)
 {
 	t_pg_composite_coder *this = RTYPEDDATA_DATA( self );
 
+	rb_check_frozen(self);
 	if ( NIL_P(elem_type) ){
 		this->elem = NULL;
 	} else if ( rb_obj_is_kind_of(elem_type, rb_cPG_Coder) ){
@@ -452,10 +460,10 @@ static const rb_data_type_t pg_coder_cfunc_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | PG_RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
-void
+VALUE
 pg_define_coder( const char *name, void *func, VALUE base_klass, VALUE nsp )
 {
 	VALUE cfunc_obj = TypedData_Wrap_Struct( rb_cObject, &pg_coder_cfunc_type, func );
@@ -468,9 +476,10 @@ pg_define_coder( const char *name, void *func, VALUE base_klass, VALUE nsp )
 	if( nsp==rb_mPG_BinaryDecoder || nsp==rb_mPG_TextDecoder )
 		rb_define_method( coder_klass, "decode", pg_coder_decode, -1 );
 
-	rb_define_const( coder_klass, "CFUNC", cfunc_obj );
+	rb_define_const( coder_klass, "CFUNC", rb_obj_freeze(cfunc_obj) );
 
 	RB_GC_GUARD(cfunc_obj);
+	return coder_klass;
 }