pg 1.2.3 → 1.3.1

data/ext/extconf.rb

@@ -15,6 +15,13 @@ if pgdir = with_config( 'pg' )
 	ENV['PATH'] = "#{pgdir}/bin" + File::PATH_SEPARATOR + ENV['PATH']
 end
 
+if enable_config("gvl-unlock", true)
+	$defs.push( "-DENABLE_GVL_UNLOCK" )
+	$stderr.puts "Calling libpq with GVL unlocked"
+else
+	$stderr.puts "Calling libpq with GVL locked"
+end
+
 if enable_config("windows-cross")
 	# Avoid dependency to external libgcc.dll on x86-mingw32
 	$LDFLAGS << " -static-libgcc"
@@ -34,31 +41,93 @@ else
 		libdir = `"#{pgconfig}" --libdir`.chomp
 		dir_config 'pg', incdir, libdir
 
-		# Try to use runtime path linker option, even if RbConfig doesn't know about it.
-		# The rpath option is usually set implicit by dir_config(), but so far not
-		# on MacOS-X.
-		if RbConfig::CONFIG["RPATHFLAG"].to_s.empty? && try_link('int main() {return 0;}', " -Wl,-rpath,#{libdir}")
-			$LDFLAGS << " -Wl,-rpath,#{libdir}"
+		# Windows traditionally stores DLLs beside executables, not in libdir
+		dlldir = RUBY_PLATFORM=~/mingw|mswin/ ? `"#{pgconfig}" --bindir`.chomp : libdir
+
+	elsif checking_for "libpq per pkg-config" do
+			_cflags, ldflags, _libs = pkg_config("libpq")
+			dlldir = ldflags && ldflags[/-L([^ ]+)/] && $1
 		end
+
 	else
-		$stderr.puts "No pg_config... trying anyway. If building fails, please try again with",
-			" --with-pg-config=/path/to/pg_config"
-		dir_config 'pg'
+		incdir, libdir = dir_config 'pg'
+		dlldir = libdir
 	end
+
+	# Try to use runtime path linker option, even if RbConfig doesn't know about it.
+	# The rpath option is usually set implicit by dir_config(), but so far not
+	# on MacOS-X.
+	if dlldir && RbConfig::CONFIG["RPATHFLAG"].to_s.empty?
+		append_ldflags "-Wl,-rpath,#{dlldir.quote}"
+	end
+end
+
+$stderr.puts "Using libpq from #{dlldir}"
+
+File.write("postgresql_lib_path.rb", <<-EOT)
+module PG
+	POSTGRESQL_LIB_PATH = #{dlldir.inspect}
 end
+EOT
+$INSTALLFILES = {
+	"./postgresql_lib_path.rb" => "$(RUBYLIBDIR)/pg/"
+}
 
 if RUBY_VERSION >= '2.3.0' && /solaris/ =~ RUBY_PLATFORM
 	append_cppflags( '-D__EXTENSIONS__' )
 end
 
-find_header( 'libpq-fe.h' ) or abort "Can't find the 'libpq-fe.h header"
-find_header( 'libpq/libpq-fs.h' ) or abort "Can't find the 'libpq/libpq-fs.h header"
-find_header( 'pg_config_manual.h' ) or abort "Can't find the 'pg_config_manual.h' header"
+begin
+	find_header( 'libpq-fe.h' ) or abort "Can't find the 'libpq-fe.h header"
+	find_header( 'libpq/libpq-fs.h' ) or abort "Can't find the 'libpq/libpq-fs.h header"
+	find_header( 'pg_config_manual.h' ) or abort "Can't find the 'pg_config_manual.h' header"
+
+	abort "Can't find the PostgreSQL client library (libpq)" unless
+		have_library( 'pq', 'PQconnectdb', ['libpq-fe.h'] ) ||
+		have_library( 'libpq', 'PQconnectdb', ['libpq-fe.h'] ) ||
+		have_library( 'ms/libpq', 'PQconnectdb', ['libpq-fe.h'] )
+
+rescue SystemExit => err
+	install_text = case RUBY_PLATFORM
+	when /linux/
+	<<-EOT
+Please install libpq or postgresql client package like so:
+  sudo apt install libpq-dev
+  sudo yum install postgresql-devel
+  sudo zypper in postgresql-devel
+  sudo pacman -S postgresql-libs
+EOT
+	when /darwin/
+	<<-EOT
+Please install libpq or postgresql client package like so:
+  brew install libpq
+EOT
+	when /mingw/
+	<<-EOT
+Please install libpq or postgresql client package like so:
+  ridk exec sh -c "pacman -S ${MINGW_PACKAGE_PREFIX}-postgresql"
+EOT
+	else
+	<<-EOT
+Please install libpq or postgresql client package.
+EOT
+	end
+
+	$stderr.puts <<-EOT
+*****************************************************************************
+
+Unable to find PostgreSQL client library.
+
+#{install_text}
+or try again with:
+  gem install pg -- --with-pg-config=/path/to/pg_config
 
-abort "Can't find the PostgreSQL client library (libpq)" unless
-	have_library( 'pq', 'PQconnectdb', ['libpq-fe.h'] ) ||
-	have_library( 'libpq', 'PQconnectdb', ['libpq-fe.h'] ) ||
-	have_library( 'ms/libpq', 'PQconnectdb', ['libpq-fe.h'] )
+or set library paths manually with:
+  gem install pg -- --with-pg-include=/path/to/libpq-fe.h/ --with-pg-lib=/path/to/libpq.so/
+
+EOT
+	raise
+end
 
 if /mingw/ =~ RUBY_PLATFORM && RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
 	# Work around: https://sourceware.org/bugzilla/show_bug.cgi?id=22504
@@ -69,21 +138,24 @@ if /mingw/ =~ RUBY_PLATFORM && RbConfig::MAKEFILE_CONFIG['CC'] =~ /gcc/
 	end
 end
 
-# optional headers/functions
-have_func 'PQsetSingleRowMode' or
+have_func 'PQconninfo' or
 	abort "Your PostgreSQL is too old. Either install an older version " +
-	      "of this gem or upgrade your database to at least PostgreSQL-9.2."
-have_func 'PQconninfo' # since PostgreSQL-9.3
+	      "of this gem or upgrade your database to at least PostgreSQL-9.3."
+# optional headers/functions
 have_func 'PQsslAttribute' # since PostgreSQL-9.5
 have_func 'PQresultVerboseErrorMessage' # since PostgreSQL-9.6
 have_func 'PQencryptPasswordConn' # since PostgreSQL-10
 have_func 'PQresultMemorySize' # since PostgreSQL-12
+have_func 'PQenterPipelineMode' # since PostgreSQL-14
 have_func 'timegm'
 have_func 'rb_gc_adjust_memory_usage' # since ruby-2.4
+have_func 'rb_gc_mark_movable' # since ruby-2.7
+have_func 'rb_io_wait' # since ruby-3.0
 
 # unistd.h confilicts with ruby/win32.h when cross compiling for win32 and ruby 1.9.1
 have_header 'unistd.h'
 have_header 'inttypes.h'
+have_header('ruby/fiber/scheduler.h') if RUBY_PLATFORM=~/mingw|mswin/
 
 checking_for "C99 variable length arrays" do
 	$defs.push( "-DHAVE_VARIABLE_LENGTH_ARRAYS" ) if try_compile('void test_vla(int l){ int vla[l]; }')

data/ext/gvl_wrappers.c

@@ -9,9 +9,13 @@
 char *PQencryptPasswordConn(PGconn *conn, const char *passwd, const char *user, const char *algorithm){return NULL;}
 #endif
 
+#ifdef ENABLE_GVL_UNLOCK
 FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
 FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_SKELETON );
+#endif
 FOR_EACH_BLOCKING_FUNCTION( DEFINE_GVL_STUB );
+#ifdef ENABLE_GVL_UNLOCK
 FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVL_WRAPPER_STRUCT );
 FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_SKELETON );
+#endif
 FOR_EACH_CALLBACK_FUNCTION( DEFINE_GVLCB_STUB );

data/ext/gvl_wrappers.h

@@ -17,6 +17,10 @@
 
 #include <ruby/thread.h>
 
+#ifdef RUBY_EXTCONF_H
+#	include RUBY_EXTCONF_H
+#endif
+
 #define DEFINE_PARAM_LIST1(type, name) \
 	name,
 
@@ -46,6 +50,7 @@
 		return NULL; \
 	}
 
+#ifdef ENABLE_GVL_UNLOCK
 #define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
 	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
 		struct gvl_wrapper_##name##_params params = { \
@@ -54,6 +59,13 @@
 		rb_thread_call_without_gvl(gvl_##name##_skeleton, &params, RUBY_UBF_IO, 0); \
 		when_non_void( return params.retval; ) \
 	}
+#else
+#define DEFINE_GVL_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+		when_non_void( return ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
+	}
+#endif
 
 #define DEFINE_GVL_STUB_DECL(name, when_non_void, rettype, lastparamtype, lastparamname) \
 	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname);
@@ -66,6 +78,7 @@
 		return NULL; \
 	}
 
+#ifdef ENABLE_GVL_UNLOCK
 #define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
 	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
 		struct gvl_wrapper_##name##_params params = { \
@@ -74,6 +87,13 @@
 		rb_thread_call_with_gvl(gvl_##name##_skeleton, &params); \
 		when_non_void( return params.retval; ) \
 	}
+#else
+#define DEFINE_GVLCB_STUB(name, when_non_void, rettype, lastparamtype, lastparamname) \
+	rettype gvl_##name(FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST3) lastparamtype lastparamname){ \
+		when_non_void( return ) \
+			name( FOR_EACH_PARAM_OF_##name(DEFINE_PARAM_LIST1) lastparamname ); \
+	}
+#endif
 
 #define GVL_TYPE_VOID(string)
 #define GVL_TYPE_NONVOID(string) string
@@ -95,6 +115,8 @@
 
 #define FOR_EACH_PARAM_OF_PQresetPoll(param)
 
+#define FOR_EACH_PARAM_OF_PQping(param)
+
 #define FOR_EACH_PARAM_OF_PQexec(param) \
 	param(PGconn *, conn)
 
@@ -196,6 +218,7 @@
 	function(PQreset, GVL_TYPE_VOID, void, PGconn *, conn) \
 	function(PQresetStart, GVL_TYPE_NONVOID, int, PGconn *, conn) \
 	function(PQresetPoll, GVL_TYPE_NONVOID, PostgresPollingStatusType, PGconn *, conn) \
+	function(PQping, GVL_TYPE_NONVOID, PGPing, const char *, conninfo) \
 	function(PQexec, GVL_TYPE_NONVOID, PGresult *, const char *, command) \
 	function(PQexecParams, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \
 	function(PQexecPrepared, GVL_TYPE_NONVOID, PGresult *, int, resultFormat) \

data/ext/pg.c

@@ -47,6 +47,7 @@
  */
 
 #include "pg.h"
+#include "pg_config.h"
 
 int pg_skip_deprecation_warning;
 VALUE rb_mPG;
@@ -415,14 +416,34 @@ Init_pg_ext()
 	rb_define_const(rb_mPGconstants, "CONNECTION_MADE", INT2FIX(CONNECTION_MADE));
 	/* Waiting for a response from the server. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_AWAITING_RESPONSE", INT2FIX(CONNECTION_AWAITING_RESPONSE));
-	/* Received authentication; waiting for backend start-up to finish. */
+	/* Received authentication; waiting for backend startup. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_AUTH_OK", INT2FIX(CONNECTION_AUTH_OK));
+	/* This state is no longer used. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_SETENV", INT2FIX(CONNECTION_SETENV));
 	/* Negotiating SSL encryption. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_SSL_STARTUP", INT2FIX(CONNECTION_SSL_STARTUP));
-	/* Negotiating environment-driven parameter settings. */
-	rb_define_const(rb_mPGconstants, "CONNECTION_SETENV", INT2FIX(CONNECTION_SETENV));
 	/* Internal state - PG.connect() needed. */
 	rb_define_const(rb_mPGconstants, "CONNECTION_NEEDED", INT2FIX(CONNECTION_NEEDED));
+#if PG_MAJORVERSION_NUM >= 10
+	/* Checking if session is read-write. Available since PostgreSQL-10. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_CHECK_WRITABLE", INT2FIX(CONNECTION_CHECK_WRITABLE));
+#endif
+#if PG_MAJORVERSION_NUM >= 10
+	/* Consuming any extra messages. Available since PostgreSQL-10. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_CONSUME", INT2FIX(CONNECTION_CONSUME));
+#endif
+#if PG_MAJORVERSION_NUM >= 12
+	/* Negotiating GSSAPI. Available since PostgreSQL-12. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_GSS_STARTUP", INT2FIX(CONNECTION_GSS_STARTUP));
+#endif
+#if PG_MAJORVERSION_NUM >= 13
+	/* Checking target server properties. Available since PostgreSQL-13. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_CHECK_TARGET", INT2FIX(CONNECTION_CHECK_TARGET));
+#endif
+#if PG_MAJORVERSION_NUM >= 14
+	/* Checking if server is in standby mode. Available since PostgreSQL-14. */
+	rb_define_const(rb_mPGconstants, "CONNECTION_CHECK_STANDBY", INT2FIX(CONNECTION_CHECK_STANDBY));
+#endif
 
 	/******     PG::Connection CLASS CONSTANTS: Nonblocking connection polling status     ******/
 
@@ -526,6 +547,19 @@ Init_pg_ext()
 	/* Result#result_status constant - Single tuple from larger resultset. */
 	rb_define_const(rb_mPGconstants, "PGRES_SINGLE_TUPLE", INT2FIX(PGRES_SINGLE_TUPLE));
 
+#ifdef HAVE_PQENTERPIPELINEMODE
+	/* Result#result_status constant - The PG::Result represents a synchronization point in pipeline mode, requested by Connection#pipeline_sync.
+	 *
+	 * This status occurs only when pipeline mode has been selected. */
+	rb_define_const(rb_mPGconstants, "PGRES_PIPELINE_SYNC", INT2FIX(PGRES_PIPELINE_SYNC));
+
+	/* Result#result_status constant - The PG::Result represents a pipeline that has received an error from the server.
+	 *
+	 * Connection#get_result must be called repeatedly, and each time it will return this status code until the end of the current pipeline, at which point it will return PG::PGRES_PIPELINE_SYNC and normal processing can resume.
+	 */
+	rb_define_const(rb_mPGconstants, "PGRES_PIPELINE_ABORTED", INT2FIX(PGRES_PIPELINE_ABORTED));
+#endif
+
 	/******     Result CONSTANTS: result error field codes      ******/
 
 	/* Result#result_error_field argument constant
@@ -549,7 +583,7 @@ Init_pg_ext()
 	/* 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 specic operations (such as error handling) in response to a particular database 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.
 	 * For a list of the possible SQLSTATE codes, see Appendix A.
 	 * This field is not localizable, and is always present.
 	 */
@@ -645,6 +679,27 @@ Init_pg_ext()
 	rb_define_const(rb_mPGconstants, "PG_DIAG_CONSTRAINT_NAME", INT2FIX(PG_DIAG_CONSTRAINT_NAME));
 #endif
 
+#ifdef HAVE_PQENTERPIPELINEMODE
+	/* Connection#pipeline_status constant
+	 *
+	 * The libpq connection is in pipeline mode.
+	 */
+	rb_define_const(rb_mPGconstants, "PQ_PIPELINE_ON", INT2FIX(PQ_PIPELINE_ON));
+
+	/* Connection#pipeline_status constant
+	 *
+	 * The libpq connection is not in pipeline mode.
+	 */
+	rb_define_const(rb_mPGconstants, "PQ_PIPELINE_OFF", INT2FIX(PQ_PIPELINE_OFF));
+
+	/* Connection#pipeline_status constant
+	 *
+	 * The libpq connection is in pipeline mode and an error occurred while processing the current pipeline.
+	 * The aborted flag is cleared when PQgetResult returns a result of type PGRES_PIPELINE_SYNC.
+	 */
+	rb_define_const(rb_mPGconstants, "PQ_PIPELINE_ABORTED", INT2FIX(PQ_PIPELINE_ABORTED));
+#endif
+
 	/* Invalid OID constant */
 	rb_define_const(rb_mPGconstants, "INVALID_OID", INT2FIX(InvalidOid));
 	rb_define_const(rb_mPGconstants, "InvalidOid", INT2FIX(InvalidOid));

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 );