pg 1.4.6-x64-mingw32 → 1.5.0-x64-mingw32

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

data/ext/pg_connection.c

@@ -16,9 +16,6 @@ static ID s_id_autoclose_set;
 static VALUE sym_type, sym_format, sym_value;
 static VALUE sym_symbol, sym_string, sym_static_symbol;
 
-static PQnoticeReceiver default_notice_receiver = NULL;
-static PQnoticeProcessor default_notice_processor = NULL;
-
 static VALUE pgconn_finish( VALUE );
 static VALUE pgconn_set_default_encoding( VALUE self );
 static VALUE pgconn_wait_for_flush( VALUE self );
@@ -117,7 +114,7 @@ pgconn_close_socket_io( VALUE self )
 		rb_funcall( socket_io, rb_intern("close"), 0 );
 	}
 
-	this->socket_io = Qnil;
+	RB_OBJ_WRITE(self, &this->socket_io, Qnil);
 }
 
 
@@ -237,7 +234,7 @@ static const rb_data_type_t pg_connection_type = {
 	},
 	0,
 	0,
-	0,
+	RUBY_TYPED_WB_PROTECTED,
 };
 
 
@@ -258,14 +255,14 @@ pgconn_s_allocate( VALUE klass )
 	VALUE self = TypedData_Make_Struct( klass, t_pg_connection, &pg_connection_type, this );
 
 	this->pgconn = NULL;
-	this->socket_io = Qnil;
-	this->notice_receiver = Qnil;
-	this->notice_processor = Qnil;
-	this->type_map_for_queries = pg_typemap_all_strings;
-	this->type_map_for_results = pg_typemap_all_strings;
-	this->encoder_for_put_copy_data = Qnil;
-	this->decoder_for_get_copy_data = Qnil;
-	this->trace_stream = Qnil;
+	RB_OBJ_WRITE(self, &this->socket_io, Qnil);
+	RB_OBJ_WRITE(self, &this->notice_receiver, Qnil);
+	RB_OBJ_WRITE(self, &this->notice_processor, Qnil);
+	RB_OBJ_WRITE(self, &this->type_map_for_queries, pg_typemap_all_strings);
+	RB_OBJ_WRITE(self, &this->type_map_for_results, pg_typemap_all_strings);
+	RB_OBJ_WRITE(self, &this->encoder_for_put_copy_data, Qnil);
+	RB_OBJ_WRITE(self, &this->decoder_for_get_copy_data, Qnil);
+	RB_OBJ_WRITE(self, &this->trace_stream, Qnil);
 	rb_ivar_set(self, rb_intern("@calls_to_put_copy_data"), INT2FIX(0));
 
 	return self;
@@ -766,6 +763,10 @@ pgconn_conninfo( VALUE self )
  *
  * ... and other constants of kind PG::Constants::CONNECTION_*
  *
+ * This method returns the status of the last command from memory.
+ * It doesn't do any socket access hence is not suitable to test the connectivity.
+ * See check_socket for a way to verify the socket state.
+ *
  * Example:
  *   PG.constants.grep(/CONNECTION_/).find{|c| PG.const_get(c) == conn.status} # => :CONNECTION_OK
  */
@@ -941,7 +942,7 @@ pgconn_socket_io(VALUE self)
 		/* Disable autoclose feature */
 		rb_funcall( socket_io, s_id_autoclose_set, 1, Qfalse );
 
-		this->socket_io = socket_io;
+		RB_OBJ_WRITE(self, &this->socket_io, socket_io);
 	}
 
 	return socket_io;
@@ -1158,7 +1159,7 @@ static const rb_data_type_t pg_typecast_buffer_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static char *
@@ -1191,7 +1192,7 @@ static const rb_data_type_t pg_query_heap_pool_type = {
 	},
 	0,
 	0,
-	RUBY_TYPED_FREE_IMMEDIATELY,
+	RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 static int
@@ -1814,6 +1815,7 @@ pgconn_set_single_row_mode(VALUE self)
 {
 	PGconn *conn = pg_get_pgconn(self);
 
+	rb_check_frozen(self);
 	if( PQsetSingleRowMode(conn) == 0 )
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 
@@ -2148,6 +2150,7 @@ pgconn_sync_setnonblocking(VALUE self, VALUE state)
 {
 	int arg;
 	PGconn *conn = pg_get_pgconn(self);
+	rb_check_frozen(self);
 	if(state == Qtrue)
 		arg = 1;
 	else if (state == Qfalse)
@@ -2464,6 +2467,7 @@ pgconn_wait_for_flush( VALUE self ){
 static VALUE
 pgconn_flush_data_set( VALUE self, VALUE enabled ){
 	t_pg_connection *conn = pg_get_connection(self);
+	rb_check_frozen(self);
 	conn->flush_data = RTEST(enabled);
 	return enabled;
 }
@@ -2718,6 +2722,7 @@ pgconn_trace(VALUE self, VALUE stream)
 	VALUE new_file;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
+	rb_check_frozen(self);
 	if(!rb_respond_to(stream,rb_intern("fileno")))
 		rb_raise(rb_eArgError, "stream does not respond to method: fileno");
 
@@ -2739,7 +2744,7 @@ pgconn_trace(VALUE self, VALUE stream)
 		rb_raise(rb_eArgError, "stream is not writable");
 
 	new_file = rb_funcall(rb_cIO, rb_intern("new"), 1, INT2NUM(new_fd));
-	this->trace_stream = new_file;
+	RB_OBJ_WRITE(self, &this->trace_stream, new_file);
 
 	PQtrace(this->pgconn, new_fp);
 	return Qnil;
@@ -2758,7 +2763,7 @@ pgconn_untrace(VALUE self)
 
 	PQuntrace(this->pgconn);
 	rb_funcall(this->trace_stream, rb_intern("close"), 0);
-	this->trace_stream = Qnil;
+	RB_OBJ_WRITE(self, &this->trace_stream, Qnil);
 	return Qnil;
 }
 
@@ -2817,13 +2822,14 @@ pgconn_set_notice_receiver(VALUE self)
 	VALUE proc, old_proc;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
+	rb_check_frozen(self);
 	/* If default_notice_receiver is unset, assume that the current
 	 * notice receiver is the default, and save it to a global variable.
 	 * This should not be a problem because the default receiver is
 	 * always the same, so won't vary among connections.
 	 */
-	if(default_notice_receiver == NULL)
-		default_notice_receiver = PQsetNoticeReceiver(this->pgconn, NULL, NULL);
+	if(this->default_notice_receiver == NULL)
+		this->default_notice_receiver = PQsetNoticeReceiver(this->pgconn, NULL, NULL);
 
 	old_proc = this->notice_receiver;
 	if( rb_block_given_p() ) {
@@ -2832,10 +2838,10 @@ pgconn_set_notice_receiver(VALUE self)
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
-		PQsetNoticeReceiver(this->pgconn, default_notice_receiver, NULL);
+		PQsetNoticeReceiver(this->pgconn, this->default_notice_receiver, NULL);
 	}
 
-	this->notice_receiver = proc;
+	RB_OBJ_WRITE(self, &this->notice_receiver, proc);
 	return old_proc;
 }
 
@@ -2850,10 +2856,10 @@ notice_processor_proxy(void *arg, const char *message)
 	VALUE self = (VALUE)arg;
 	t_pg_connection *this = pg_get_connection( self );
 
-	if (this->notice_receiver != Qnil) {
+	if (this->notice_processor != Qnil) {
 		VALUE message_str = rb_str_new2(message);
 		PG_ENCODING_SET_NOCHECK( message_str, this->enc_idx );
-		rb_funcall(this->notice_receiver, rb_intern("call"), 1, message_str);
+		rb_funcall(this->notice_processor, rb_intern("call"), 1, message_str);
 	}
 	return;
 }
@@ -2877,25 +2883,26 @@ pgconn_set_notice_processor(VALUE self)
 	VALUE proc, old_proc;
 	t_pg_connection *this = pg_get_connection_safe( self );
 
+	rb_check_frozen(self);
 	/* If default_notice_processor is unset, assume that the current
 	 * notice processor is the default, and save it to a global variable.
 	 * This should not be a problem because the default processor is
 	 * always the same, so won't vary among connections.
 	 */
-	if(default_notice_processor == NULL)
-		default_notice_processor = PQsetNoticeProcessor(this->pgconn, NULL, NULL);
+	if(this->default_notice_processor == NULL)
+		this->default_notice_processor = PQsetNoticeProcessor(this->pgconn, NULL, NULL);
 
-	old_proc = this->notice_receiver;
+	old_proc = this->notice_processor;
 	if( rb_block_given_p() ) {
 		proc = rb_block_proc();
 		PQsetNoticeProcessor(this->pgconn, gvl_notice_processor_proxy, (void *)self);
 	} else {
 		/* if no block is given, set back to default */
 		proc = Qnil;
-		PQsetNoticeProcessor(this->pgconn, default_notice_processor, NULL);
+		PQsetNoticeProcessor(this->pgconn, this->default_notice_processor, NULL);
 	}
 
-	this->notice_receiver = proc;
+	RB_OBJ_WRITE(self, &this->notice_processor, proc);
 	return old_proc;
 }
 
@@ -2927,6 +2934,7 @@ pgconn_sync_set_client_encoding(VALUE self, VALUE str)
 {
 	PGconn *conn = pg_get_pgconn( self );
 
+	rb_check_frozen(self);
 	Check_Type(str, T_STRING);
 
 	if ( (gvl_PQsetClientEncoding(conn, StringValueCStr(str))) == -1 )
@@ -3095,7 +3103,7 @@ pgconn_async_get_last_result(VALUE self)
 	VALUE rb_pgresult = Qnil;
 	PGresult *cur, *prev;
 
-  cur = prev = NULL;
+	cur = prev = NULL;
 	for(;;) {
 		int status;
 
@@ -4058,6 +4066,7 @@ static VALUE pgconn_external_encoding(VALUE self);
 static VALUE
 pgconn_internal_encoding_set(VALUE self, VALUE enc)
 {
+	rb_check_frozen(self);
 	if (NIL_P(enc)) {
 		pgconn_sync_set_client_encoding( self, rb_usascii_str_new_cstr("SQL_ASCII") );
 		return enc;
@@ -4112,6 +4121,7 @@ pgconn_async_set_client_encoding(VALUE self, VALUE encname)
 {
 	VALUE query_format, query;
 
+	rb_check_frozen(self);
 	Check_Type(encname, T_STRING);
 	query_format = rb_str_new_cstr("set client_encoding to '%s'");
 	query = rb_funcall(query_format, rb_intern("%"), 1, encname);
@@ -4164,6 +4174,7 @@ pgconn_set_default_encoding( VALUE self )
 	rb_encoding *enc;
 	const char *encname;
 
+	rb_check_frozen(self);
 	if (( enc = rb_default_internal_encoding() )) {
 		encname = pg_get_rb_encoding_as_pg_encoding( enc );
 		if ( pgconn_set_client_encoding_async(self, rb_str_new_cstr(encname)) != 0 )
@@ -4193,10 +4204,11 @@ pgconn_type_map_for_queries_set(VALUE self, VALUE typemap)
 	t_typemap *tm;
 	UNUSED(tm);
 
+	rb_check_frozen(self);
 	/* Check type of method param */
 	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
 
-	this->type_map_for_queries = typemap;
+	RB_OBJ_WRITE(self, &this->type_map_for_queries, typemap);
 
 	return typemap;
 }
@@ -4233,8 +4245,9 @@ pgconn_type_map_for_results_set(VALUE self, VALUE typemap)
 	t_typemap *tm;
 	UNUSED(tm);
 
+	rb_check_frozen(self);
 	TypedData_Get_Struct(typemap, t_typemap, &pg_typemap_type, tm);
-	this->type_map_for_results = typemap;
+	RB_OBJ_WRITE(self, &this->type_map_for_results, typemap);
 
 	return typemap;
 }
@@ -4272,13 +4285,14 @@ pgconn_encoder_for_put_copy_data_set(VALUE self, VALUE encoder)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
+	rb_check_frozen(self);
 	if( encoder != Qnil ){
 		t_pg_coder *co;
 		UNUSED(co);
 		/* Check argument type */
 		TypedData_Get_Struct(encoder, t_pg_coder, &pg_coder_type, co);
 	}
-	this->encoder_for_put_copy_data = encoder;
+	RB_OBJ_WRITE(self, &this->encoder_for_put_copy_data, encoder);
 
 	return encoder;
 }
@@ -4320,13 +4334,14 @@ pgconn_decoder_for_get_copy_data_set(VALUE self, VALUE decoder)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
+	rb_check_frozen(self);
 	if( decoder != Qnil ){
 		t_pg_coder *co;
 		UNUSED(co);
 		/* Check argument type */
 		TypedData_Get_Struct(decoder, t_pg_coder, &pg_coder_type, co);
 	}
-	this->decoder_for_get_copy_data = decoder;
+	RB_OBJ_WRITE(self, &this->decoder_for_get_copy_data, decoder);
 
 	return decoder;
 }
@@ -4372,6 +4387,7 @@ pgconn_field_name_type_set(VALUE self, VALUE sym)
 {
 	t_pg_connection *this = pg_get_connection( self );
 
+	rb_check_frozen(self);
 	this->flags &= ~PG_RESULT_FIELD_NAMES_MASK;
 	if( sym == sym_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_SYMBOL;
 	else if ( sym == sym_static_symbol ) this->flags |= PG_RESULT_FIELD_NAMES_STATIC_SYMBOL;