pg 1.1.4 → 1.5.3

data/ext/pg.h

@@ -11,6 +11,7 @@
 #include <sys/types.h>
 #if !defined(_WIN32)
 #	include <sys/time.h>
+#	include <sys/socket.h>
 #endif
 #if defined(HAVE_UNISTD_H) && !defined(_WIN32)
 #	include <unistd.h>
@@ -56,6 +57,7 @@
 #endif
 
 /* PostgreSQL headers */
+#include "pg_config.h"
 #include "libpq-fe.h"
 #include "libpq/libpq-fs.h"              /* large-object interface */
 #include "pg_config_manual.h"
@@ -74,9 +76,22 @@ typedef long suseconds_t;
 	#define PG_MAX_COLUMNS 4000
 #endif
 
-#ifndef RARRAY_AREF
-#define RARRAY_AREF(a, i) (RARRAY_PTR(a)[i])
+#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
+#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 */
 typedef struct {
@@ -84,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 */
@@ -94,15 +112,16 @@ typedef struct {
 	VALUE type_map_for_results;
 	/* IO object internally used for the trace stream */
 	VALUE trace_stream;
-	/* Cached Encoding object */
-	VALUE external_encoding;
 	/* Kind of PG::Coder object for casting ruby values to COPY rows */
 	VALUE encoder_for_put_copy_data;
 	/* Kind of PG::Coder object for casting COPY rows to ruby values */
 	VALUE decoder_for_get_copy_data;
-
-	/* enable/disable guessing size of PGresult's allocated memory */
-	int guess_result_memsize;
+	/* 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;
+	/* 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() */
@@ -128,10 +147,16 @@ typedef struct {
 	 */
 	t_typemap *p_typemap;
 
+	/* Ruby encoding index of the client/internal encoding */
+	int enc_idx : PG_ENC_IDX_BITS;
+
 	/* 0 = PGresult is cleared by PG::Result#clear or by the GC
 	 * 1 = PGresult is cleared internally by libpq
 	 */
-	int autoclear;
+	unsigned int autoclear : 1;
+
+	/* flags controlling Symbol/String field names */
+	unsigned int flags : 2;
 
 	/* Number of fields in fnames[] .
 	 * Set to -1 if fnames[] is not yet initialized.
@@ -147,7 +172,7 @@ typedef struct {
 	/* Hash with fnames[] to field number mapping. */
 	VALUE field_map;
 
-	/* List of field names as frozen String objects.
+	/* List of field names as frozen String or Symbol objects.
 	 * Only valid if nfields != -1
 	 */
 	VALUE fnames[0];
@@ -163,6 +188,10 @@ 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_SYMBOL 0x01
+#define PG_RESULT_FIELD_NAMES_STATIC_SYMBOL 0x02
+
 #define PG_CODER_TIMESTAMP_DB_UTC 0x0
 #define PG_CODER_TIMESTAMP_DB_LOCAL 0x1
 #define PG_CODER_TIMESTAMP_APP_UTC 0x0
@@ -209,6 +238,8 @@ typedef struct {
 	} convs[0];
 } t_tmbc;
 
+extern const rb_data_type_t pg_typemap_type;
+extern const rb_data_type_t pg_coder_type;
 
 #include "gvl_wrappers.h"
 
@@ -275,6 +306,7 @@ void init_pg_type_map_by_oid                           _(( void ));
 void init_pg_type_map_in_ruby                          _(( void ));
 void init_pg_coder                                     _(( void ));
 void init_pg_copycoder                                 _(( void ));
+void init_pg_recordcoder                               _(( void ));
 void init_pg_text_encoder                              _(( void ));
 void init_pg_text_decoder                              _(( void ));
 void init_pg_binary_encoder                            _(( void ));
@@ -287,11 +319,12 @@ 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 ));
 void pg_coder_init_decoder                             _(( VALUE ));
+void pg_coder_compact                                  _(( void * ));
 char *pg_rb_str_ensure_capa                            _(( VALUE, long, char *, char ** ));
 
 #define PG_RB_STR_ENSURE_CAPA( str, expand_len, curr_ptr, end_ptr ) \
@@ -305,20 +338,19 @@ char *pg_rb_str_ensure_capa                            _(( VALUE, long, char *,
 		(curr_ptr) = (end_ptr) = RSTRING_PTR(str) \
 	)
 
-#define PG_RB_TAINTED_STR_NEW( str, curr_ptr, end_ptr ) ( \
-		(str) = rb_tainted_str_new( NULL, 0 ), \
-		(curr_ptr) = (end_ptr) = RSTRING_PTR(str) \
-	)
-
 VALUE pg_typemap_fit_to_result                         _(( VALUE, VALUE ));
 VALUE pg_typemap_fit_to_query                          _(( VALUE, VALUE ));
 int pg_typemap_fit_to_copy_get                         _(( VALUE ));
 VALUE pg_typemap_result_value                          _(( t_typemap *, VALUE, int, int ));
 t_pg_coder *pg_typemap_typecast_query_param            _(( t_typemap *, VALUE, int ));
 VALUE pg_typemap_typecast_copy_get                     _(( t_typemap *, VALUE, int, int, int ));
+void pg_typemap_mark                                   _(( void * ));
+size_t pg_typemap_memsize                              _(( const void * ));
+void pg_typemap_compact                                _(( void * ));
 
 PGconn *pg_get_pgconn                                  _(( VALUE ));
 t_pg_connection *pg_get_connection                     _(( VALUE ));
+VALUE pgconn_block                                     _(( int, VALUE *, VALUE ));
 
 VALUE pg_new_result                                    _(( PGresult *, VALUE ));
 VALUE pg_new_result_autoclear                          _(( PGresult *, VALUE ));
@@ -333,12 +365,7 @@ VALUE pg_tuple_new                                     _(( VALUE, int ));
 static inline t_pg_result *
 pgresult_get_this( VALUE self )
 {
-	t_pg_result *this = RTYPEDDATA_DATA(self);
-
-	if( this == NULL )
-		rb_raise(rb_ePGerror, "result has been cleared");
-
-	return this;
+	return RTYPEDDATA_DATA(self);
 }
 
 

data/ext/pg_binary_decoder.c

@@ -6,19 +6,21 @@
 
 #include "ruby/version.h"
 #include "pg.h"
-#include "util.h"
+#include "pg_util.h"
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
 
 VALUE rb_mPG_BinaryDecoder;
+static VALUE s_Date;
+static ID s_id_new;
 
 
 /*
  * Document-class: PG::BinaryDecoder::Boolean < PG::SimpleDecoder
  *
- * This is a decoder class for conversion of PostgreSQL binary bool type
- * to Ruby true or false objects.
+ * This is a decoder class for conversion of PostgreSQL binary +bool+ type
+ * to Ruby +true+ or +false+ objects.
  *
  */
 static VALUE
@@ -33,7 +35,7 @@ pg_bin_dec_boolean(t_pg_coder *conv, const char *val, int len, int tuple, int fi
 /*
  * Document-class: PG::BinaryDecoder::Integer < PG::SimpleDecoder
  *
- * This is a decoder class for conversion of PostgreSQL binary int2, int4 and int8 types
+ * This is a decoder class for conversion of PostgreSQL binary +int2+, +int4+ and +int8+ types
  * to Ruby Integer objects.
  *
  */
@@ -55,7 +57,7 @@ pg_bin_dec_integer(t_pg_coder *conv, const char *val, int len, int tuple, int fi
 /*
  * Document-class: PG::BinaryDecoder::Float < PG::SimpleDecoder
  *
- * This is a decoder class for conversion of PostgreSQL binary float4 and float8 types
+ * This is a decoder class for conversion of PostgreSQL binary +float4+ and +float8+ types
  * to Ruby Float objects.
  *
  */
@@ -87,7 +89,7 @@ pg_bin_dec_float(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
  * Document-class: PG::BinaryDecoder::Bytea < PG::SimpleDecoder
  *
  * This decoder class delivers the data received from the server as binary String object.
- * It is therefore suitable for conversion of PostgreSQL bytea data as well as any other
+ * It is therefore suitable for conversion of PostgreSQL +bytea+ data as well as any other
  * data in binary format.
  *
  */
@@ -95,7 +97,7 @@ VALUE
 pg_bin_dec_bytea(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
 	VALUE ret;
-	ret = rb_tainted_str_new( val, len );
+	ret = rb_str_new( val, len );
 	PG_ENCODING_SET_NOCHECK( ret, rb_ascii8bit_encindex() );
 	return ret;
 }
@@ -103,7 +105,7 @@ pg_bin_dec_bytea(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
 /*
  * Document-class: PG::BinaryDecoder::ToBase64 < PG::CompositeDecoder
  *
- * This is a decoder class for conversion of binary (bytea) to base64 data.
+ * This is a decoder class for conversion of binary +bytea+ to base64 data.
  *
  */
 static VALUE
@@ -113,7 +115,7 @@ pg_bin_dec_to_base64(t_pg_coder *conv, const char *val, int len, int tuple, int
 	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, this->comp.format);
 	int encoded_len = BASE64_ENCODED_SIZE(len);
 	/* create a buffer of the encoded length */
-	VALUE out_value = rb_tainted_str_new(NULL, encoded_len);
+	VALUE out_value = rb_str_new(NULL, encoded_len);
 
 	base64_encode( RSTRING_PTR(out_value), val, len );
 
@@ -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
  *
@@ -205,10 +283,11 @@ pg_bin_dec_timestamp(t_pg_coder *conv, const char *val, int len, int tuple, int
  */
 
 void
-init_pg_binary_decoder()
+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

@@ -1,16 +1,19 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_binary_encoder.c,v e61a06f1f5ed 2015/12/25 21:14:21 lars $
+ * $Id$
  *
  */
 
 #include "pg.h"
-#include "util.h"
+#include "pg_util.h"
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
 
 VALUE rb_mPG_BinaryEncoder;
+static ID s_id_year;
+static ID s_id_month;
+static ID s_id_day;
 
 
 /*
@@ -25,11 +28,12 @@ static int
 pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	char mybool;
-	switch(value){
-		case Qtrue : mybool = 1; break;
-		case Qfalse : mybool = 0; break;
-		default :
-			rb_raise( rb_eTypeError, "wrong data for binary boolean converter" );
+    if (value == Qtrue) {
+      mybool = 1;
+    } else if (value == Qfalse) {
+      mybool = 0;
+    } else {
+      rb_raise( rb_eTypeError, "wrong data for binary boolean converter" );
 	}
 	if(out) *out = mybool;
 	return 1;
@@ -38,7 +42,7 @@ pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate
 /*
  * Document-class: PG::BinaryEncoder::Int2 < PG::SimpleEncoder
  *
- * This is the encoder class for the PostgreSQL int2 type.
+ * This is the encoder class for the PostgreSQL +int2+ (alias +smallint+) type.
  *
  * Non-Number values are expected to have method +to_i+ defined.
  *
@@ -55,9 +59,9 @@ pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, i
 }
 
 /*
- * Document-class: PG::BinaryEncoder::Int2 < PG::SimpleEncoder
+ * Document-class: PG::BinaryEncoder::Int4 < PG::SimpleEncoder
  *
- * This is the encoder class for the PostgreSQL int4 type.
+ * This is the encoder class for the PostgreSQL +int4+ (alias +integer+) type.
  *
  * Non-Number values are expected to have method +to_i+ defined.
  *
@@ -74,9 +78,9 @@ pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, i
 }
 
 /*
- * Document-class: PG::BinaryEncoder::Int2 < PG::SimpleEncoder
+ * Document-class: PG::BinaryEncoder::Int8 < PG::SimpleEncoder
  *
- * This is the encoder class for the PostgreSQL int8 type.
+ * This is the encoder class for the PostgreSQL +int8+ (alias +bigint+) type.
  *
  * Non-Number values are expected to have method +to_i+ defined.
  *
@@ -92,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
  *
@@ -138,8 +351,12 @@ pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermed
 }
 
 void
-init_pg_binary_encoder()
+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" );
 
@@ -152,10 +369,18 @@ init_pg_binary_encoder()
 	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 );