pg 0.18.2 → 1.5.3

data/ext/pg_binary_encoder.c

@@ -1,14 +1,19 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_binary_encoder.c,v ac23631c96d9 2014/10/14 11:50: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;
 
 
 /*
@@ -20,29 +25,30 @@ VALUE rb_mPG_BinaryEncoder;
  *
  */
 static int
-pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
-	char bool;
-	switch(value){
-		case Qtrue : bool = 1; break;
-		case Qfalse : bool = 0; break;
-		default :
-			rb_raise( rb_eTypeError, "wrong data for binary boolean converter" );
+	char mybool;
+    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 = bool;
+	if(out) *out = mybool;
 	return 1;
 }
 
 /*
  * 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.
  *
  */
 static int
-pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		write_nbo16(NUM2INT(*intermediate), out);
@@ -53,15 +59,15 @@ pg_bin_enc_int2(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 }
 
 /*
- * 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.
  *
  */
 static int
-pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		write_nbo32(NUM2LONG(*intermediate), out);
@@ -72,15 +78,15 @@ pg_bin_enc_int4(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 }
 
 /*
- * 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.
  *
  */
 static int
-pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		write_nbo64(NUM2LL(*intermediate), out);
@@ -90,6 +96,215 @@ pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
 	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
  *
@@ -98,7 +313,7 @@ pg_bin_enc_int8(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
  *
  */
 static int
-pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	int strlen;
 	VALUE subint;
@@ -107,13 +322,13 @@ pg_bin_enc_from_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermed
 
 	if(out){
 		/* Second encoder pass, if required */
-		strlen = enc_func(this->elem, value, out, intermediate);
+		strlen = enc_func(this->elem, value, out, intermediate, enc_idx);
 		strlen = base64_decode( out, out, strlen );
 
 		return strlen;
 	} else {
 		/* First encoder pass */
-		strlen = enc_func(this->elem, value, NULL, &subint);
+		strlen = enc_func(this->elem, value, NULL, &subint, enc_idx);
 
 		if( strlen == -1 ){
 			/* Encoded string is returned in subint */
@@ -136,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" );
 
@@ -150,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 );