pg 1.2.3-x64-mingw32 → 1.3.0.rc1-x64-mingw32

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>
@@ -78,6 +79,15 @@ typedef long suseconds_t;
 #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)
+#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
+
 #define PG_ENC_IDX_BITS 28
 
 /* The data behind each PG::Connection object */
@@ -104,6 +114,8 @@ typedef struct {
 	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() */
@@ -220,6 +232,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"
 
@@ -304,7 +318,7 @@ 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_mark                                     _(( t_pg_coder * ));
+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 ) \
@@ -324,6 +338,9 @@ 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 ));

data/ext/pg_coder.c

@@ -26,11 +26,11 @@ pg_coder_allocate( VALUE klass )
 void
 pg_coder_init_encoder( VALUE self )
 {
-	t_pg_coder *this = DATA_PTR( self );
+	t_pg_coder *this = RTYPEDDATA_DATA( self );
 	VALUE klass = rb_class_of(self);
 	if( rb_const_defined( klass, s_id_CFUNC ) ){
 		VALUE cfunc = rb_const_get( klass, s_id_CFUNC );
-		this->enc_func = DATA_PTR(cfunc);
+		this->enc_func = RTYPEDDATA_DATA(cfunc);
 	} else {
 		this->enc_func = NULL;
 	}
@@ -45,12 +45,12 @@ pg_coder_init_encoder( VALUE self )
 void
 pg_coder_init_decoder( VALUE self )
 {
-	t_pg_coder *this = DATA_PTR( self );
+	t_pg_coder *this = RTYPEDDATA_DATA( self );
 	VALUE klass = rb_class_of(self);
 	this->enc_func = NULL;
 	if( rb_const_defined( klass, s_id_CFUNC ) ){
 		VALUE cfunc = rb_const_get( klass, s_id_CFUNC );
-		this->dec_func = DATA_PTR(cfunc);
+		this->dec_func = RTYPEDDATA_DATA(cfunc);
 	} else {
 		this->dec_func = NULL;
 	}
@@ -61,32 +61,74 @@ pg_coder_init_decoder( VALUE self )
 	rb_iv_set( self, "@name", Qnil );
 }
 
+static size_t
+pg_coder_memsize(const void *_this)
+{
+	const t_pg_coder *this = (const t_pg_coder *)_this;
+	return sizeof(*this);
+}
+
+static size_t
+pg_composite_coder_memsize(const void *_this)
+{
+	const t_pg_composite_coder *this = (const t_pg_composite_coder *)_this;
+	return sizeof(*this);
+}
+
 void
-pg_coder_mark(t_pg_coder *this)
+pg_coder_compact(void *_this)
 {
-	rb_gc_mark(this->coder_obj);
+	t_pg_coder *this = (t_pg_coder *)_this;
+	pg_gc_location(this->coder_obj);
 }
 
 static void
-pg_composite_coder_mark(t_pg_composite_coder *this)
+pg_composite_coder_compact(void *_this)
 {
-	pg_coder_mark(&this->comp);
+	t_pg_composite_coder *this = (t_pg_composite_coder *)_this;
+	pg_coder_compact(&this->comp);
 }
 
+const rb_data_type_t pg_coder_type = {
+	"PG::Coder",
+	{
+		(RUBY_DATA_FUNC) NULL,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_coder_memsize,
+		pg_compact_callback(pg_coder_compact),
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE
 pg_simple_encoder_allocate( VALUE klass )
 {
 	t_pg_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_coder, pg_coder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_coder, &pg_coder_type, this );
 	pg_coder_init_encoder( self );
 	return self;
 }
 
+static const rb_data_type_t pg_composite_coder_type = {
+	"PG::CompositeCoder",
+	{
+		(RUBY_DATA_FUNC) NULL,
+		RUBY_TYPED_DEFAULT_FREE,
+		pg_composite_coder_memsize,
+		pg_compact_callback(pg_composite_coder_compact),
+	},
+	&pg_coder_type,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 static VALUE
 pg_composite_encoder_allocate( VALUE klass )
 {
 	t_pg_composite_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_composite_coder, pg_composite_coder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_composite_coder, &pg_composite_coder_type, this );
 	pg_coder_init_encoder( self );
 	this->elem = NULL;
 	this->needs_quotation = 1;
@@ -99,7 +141,7 @@ static VALUE
 pg_simple_decoder_allocate( VALUE klass )
 {
 	t_pg_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_coder, pg_coder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_coder, &pg_coder_type, this );
 	pg_coder_init_decoder( self );
 	return self;
 }
@@ -108,7 +150,7 @@ static VALUE
 pg_composite_decoder_allocate( VALUE klass )
 {
 	t_pg_composite_coder *this;
-	VALUE self = Data_Make_Struct( klass, t_pg_composite_coder, pg_composite_coder_mark, -1, this );
+	VALUE self = TypedData_Make_Struct( klass, t_pg_composite_coder, &pg_composite_coder_type, this );
 	pg_coder_init_decoder( self );
 	this->elem = NULL;
 	this->needs_quotation = 1;
@@ -135,7 +177,7 @@ pg_coder_encode(int argc, VALUE *argv, VALUE self)
 	VALUE value;
 	int len, len2;
 	int enc_idx;
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 
 	if(argc < 1 || argc > 2){
 		rb_raise(rb_eArgError, "wrong number of arguments (%i for 1..2)", argc);
@@ -192,7 +234,7 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 	int tuple = -1;
 	int field = -1;
 	VALUE res;
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 
 	if(argc < 1 || argc > 3){
 		rb_raise(rb_eArgError, "wrong number of arguments (%i for 1..3)", argc);
@@ -213,7 +255,7 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 		rb_raise(rb_eRuntimeError, "no decoder function defined");
 	}
 
-	res = this->dec_func(this, val, RSTRING_LEN(argv[0]), tuple, field, ENCODING_GET(argv[0]));
+	res = this->dec_func(this, val, RSTRING_LENINT(argv[0]), tuple, field, ENCODING_GET(argv[0]));
 
 	return res;
 }
@@ -230,7 +272,7 @@ pg_coder_decode(int argc, VALUE *argv, VALUE self)
 static VALUE
 pg_coder_oid_set(VALUE self, VALUE oid)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	this->oid = NUM2UINT(oid);
 	return oid;
 }
@@ -245,7 +287,7 @@ pg_coder_oid_set(VALUE self, VALUE oid)
 static VALUE
 pg_coder_oid_get(VALUE self)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	return UINT2NUM(this->oid);
 }
 
@@ -261,7 +303,7 @@ pg_coder_oid_get(VALUE self)
 static VALUE
 pg_coder_format_set(VALUE self, VALUE format)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	this->format = NUM2INT(format);
 	return format;
 }
@@ -276,7 +318,7 @@ pg_coder_format_set(VALUE self, VALUE format)
 static VALUE
 pg_coder_format_get(VALUE self)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	return INT2NUM(this->format);
 }
 
@@ -292,7 +334,7 @@ pg_coder_format_get(VALUE self)
 static VALUE
 pg_coder_flags_set(VALUE self, VALUE flags)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	this->flags = NUM2INT(flags);
 	return flags;
 }
@@ -306,7 +348,7 @@ pg_coder_flags_set(VALUE self, VALUE flags)
 static VALUE
 pg_coder_flags_get(VALUE self)
 {
-	t_pg_coder *this = DATA_PTR(self);
+	t_pg_coder *this = RTYPEDDATA_DATA(self);
 	return INT2NUM(this->flags);
 }
 
@@ -323,7 +365,7 @@ pg_coder_flags_get(VALUE self)
 static VALUE
 pg_coder_needs_quotation_set(VALUE self, VALUE needs_quotation)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
 	this->needs_quotation = RTEST(needs_quotation);
 	return needs_quotation;
 }
@@ -338,7 +380,7 @@ pg_coder_needs_quotation_set(VALUE self, VALUE needs_quotation)
 static VALUE
 pg_coder_needs_quotation_get(VALUE self)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
 	return this->needs_quotation ? Qtrue : Qfalse;
 }
 
@@ -353,7 +395,7 @@ pg_coder_needs_quotation_get(VALUE self)
 static VALUE
 pg_coder_delimiter_set(VALUE self, VALUE delimiter)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
 	StringValue(delimiter);
 	if(RSTRING_LEN(delimiter) != 1)
 		rb_raise( rb_eArgError, "delimiter size must be one byte");
@@ -370,7 +412,7 @@ pg_coder_delimiter_set(VALUE self, VALUE delimiter)
 static VALUE
 pg_coder_delimiter_get(VALUE self)
 {
-	t_pg_composite_coder *this = DATA_PTR(self);
+	t_pg_composite_coder *this = RTYPEDDATA_DATA(self);
 	return rb_str_new(&this->delimiter, 1);
 }
 
@@ -386,12 +428,12 @@ pg_coder_delimiter_get(VALUE self)
 static VALUE
 pg_coder_elements_type_set(VALUE self, VALUE elem_type)
 {
-	t_pg_composite_coder *this = DATA_PTR( self );
+	t_pg_composite_coder *this = RTYPEDDATA_DATA( self );
 
 	if ( NIL_P(elem_type) ){
 		this->elem = NULL;
 	} else if ( rb_obj_is_kind_of(elem_type, rb_cPG_Coder) ){
-		this->elem = DATA_PTR( elem_type );
+		this->elem = RTYPEDDATA_DATA( elem_type );
 	} else {
 		rb_raise( rb_eTypeError, "wrong elements type %s (expected some kind of PG::Coder)",
 				rb_obj_classname( elem_type ) );
@@ -401,10 +443,22 @@ pg_coder_elements_type_set(VALUE self, VALUE elem_type)
 	return elem_type;
 }
 
+static const rb_data_type_t pg_coder_cfunc_type = {
+	"PG::Coder::CFUNC",
+	{
+		(RUBY_DATA_FUNC)NULL,
+		(RUBY_DATA_FUNC)NULL,
+		(size_t (*)(const void *))NULL,
+	},
+	0,
+	0,
+	RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 void
 pg_define_coder( const char *name, void *func, VALUE base_klass, VALUE nsp )
 {
-	VALUE cfunc_obj = Data_Wrap_Struct( rb_cObject, NULL, NULL, func );
+	VALUE cfunc_obj = TypedData_Wrap_Struct( rb_cObject, &pg_coder_cfunc_type, func );
 	VALUE coder_klass = rb_define_class_under( nsp, name, base_klass );
 	if( nsp==rb_mPG_BinaryEncoder || nsp==rb_mPG_BinaryDecoder )
 		rb_include_module( coder_klass, rb_mPG_BinaryFormatting );