pg 1.4.5 → 1.5.3

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)
@@ -2446,8 +2449,9 @@ pgconn_async_flush(VALUE self)
 		VALUE socket_io = pgconn_socket_io(self);
 		events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
 
-		if (events & PG_RUBY_IO_READABLE)
+		if (events & PG_RUBY_IO_READABLE){
 			pgconn_consume_input(self);
+		}
 	}
 	return Qtrue;
 }
@@ -2463,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;
 }
@@ -2717,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");
 
@@ -2738,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;
@@ -2757,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;
 }
 
@@ -2816,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() ) {
@@ -2831,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;
 }
 
@@ -2849,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;
 }
@@ -2876,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;
 }
 
@@ -2926,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 )
@@ -3094,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;
 
@@ -3126,8 +3135,14 @@ pgconn_async_get_last_result(VALUE self)
  *    conn.discard_results()
  *
  * Silently discard any prior query result that application didn't eat.
- * This is done prior of Connection#exec and sibling methods and can
- * be called explicitly when using the async API.
+ * This is internally used prior to Connection#exec and sibling methods.
+ * It doesn't raise an exception on connection errors, but returns +false+ instead.
+ *
+ * Returns:
+ * * +nil+  when the connection is already idle
+ * * +true+  when some results have been discarded
+ * * +false+  when a failure occured and the connection was closed
+ *
  */
 static VALUE
 pgconn_discard_results(VALUE self)
@@ -3135,8 +3150,12 @@ pgconn_discard_results(VALUE self)
 	PGconn *conn = pg_get_pgconn(self);
 	VALUE socket_io;
 
-	if( PQtransactionStatus(conn) == PQTRANS_IDLE ) {
-		return Qnil;
+	switch( PQtransactionStatus(conn) ) {
+		case PQTRANS_IDLE:
+		case PQTRANS_INTRANS:
+		case PQTRANS_INERROR:
+			return Qnil;
+		default:;
 	}
 
 	socket_io = pgconn_socket_io(self);
@@ -3149,10 +3168,21 @@ pgconn_discard_results(VALUE self)
 		* To avoid this call pg_rb_io_wait() and PQconsumeInput() without rb_raise().
 		*/
 		while( gvl_PQisBusy(conn) ){
-			pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
-			if ( PQconsumeInput(conn) == 0 ) {
-				pgconn_close_socket_io(self);
-				return Qfalse;
+			int events;
+
+			switch( PQflush(conn) ) {
+				case 1:
+					events = RB_NUM2INT(pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE | PG_RUBY_IO_WRITABLE), Qnil));
+					if (events & PG_RUBY_IO_READABLE){
+						if ( PQconsumeInput(conn) == 0 ) goto error;
+					}
+					break;
+				case 0:
+					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
+					if ( PQconsumeInput(conn) == 0 ) goto error;
+					break;
+				default:
+					goto error;
 			}
 		}
 
@@ -3162,7 +3192,9 @@ pgconn_discard_results(VALUE self)
 		status = PQresultStatus(cur);
 		PQclear(cur);
 		if (status == PGRES_COPY_IN){
-			gvl_PQputCopyEnd(conn, "COPY terminated by new PQexec");
+			while( gvl_PQputCopyEnd(conn, "COPY terminated by new query or discard_results") == 0 ){
+				pgconn_async_flush(self);
+			}
 		}
 		if (status == PGRES_COPY_OUT){
 			for(;;) {
@@ -3171,10 +3203,7 @@ pgconn_discard_results(VALUE self)
 				if( st == 0 ) {
 					/* would block -> wait for readable data */
 					pg_rb_io_wait(socket_io, RB_INT2NUM(PG_RUBY_IO_READABLE), Qnil);
-					if ( PQconsumeInput(conn) == 0 ) {
-						pgconn_close_socket_io(self);
-						return Qfalse;
-					}
+					if ( PQconsumeInput(conn) == 0 ) goto error;
 				} else if( st > 0 ) {
 					/* some data retrieved -> discard it */
 					PQfreemem(buffer);
@@ -3187,6 +3216,10 @@ pgconn_discard_results(VALUE self)
 	}
 
 	return Qtrue;
+
+error:
+	pgconn_close_socket_io(self);
+	return Qfalse;
 }
 
 /*
@@ -3643,6 +3676,14 @@ pgconn_send_flush_request(VALUE self)
  * LARGE OBJECT SUPPORT
  **************************************************************************/
 
+#define BLOCKING_BEGIN(conn) do { \
+	int old_nonblocking = PQisnonblocking(conn); \
+	PQsetnonblocking(conn, 0);
+
+#define BLOCKING_END(th) \
+	PQsetnonblocking(conn, old_nonblocking); \
+} while(0);
+
 /*
  * call-seq:
  *    conn.lo_creat( [mode] ) -> Integer
@@ -3663,7 +3704,10 @@ pgconn_locreat(int argc, VALUE *argv, VALUE self)
 	else
 		mode = NUM2INT(nmode);
 
-	lo_oid = lo_creat(conn, mode);
+	BLOCKING_BEGIN(conn)
+		lo_oid = lo_creat(conn, mode);
+	BLOCKING_END(conn)
+
 	if (lo_oid == 0)
 		pg_raise_conn_error( rb_ePGerror, self, "lo_creat failed");
 
@@ -3708,7 +3752,10 @@ pgconn_loimport(VALUE self, VALUE filename)
 
 	Check_Type(filename, T_STRING);
 
-	lo_oid = lo_import(conn, StringValueCStr(filename));
+	BLOCKING_BEGIN(conn)
+		lo_oid = lo_import(conn, StringValueCStr(filename));
+	BLOCKING_END(conn)
+
 	if (lo_oid == 0) {
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 	}
@@ -3726,11 +3773,16 @@ pgconn_loexport(VALUE self, VALUE lo_oid, VALUE filename)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	Oid oid;
+	int ret;
 	Check_Type(filename, T_STRING);
 
 	oid = NUM2UINT(lo_oid);
 
-	if (lo_export(conn, oid, StringValueCStr(filename)) < 0) {
+	BLOCKING_BEGIN(conn)
+		ret = lo_export(conn, oid, StringValueCStr(filename));
+	BLOCKING_END(conn)
+
+	if (ret < 0) {
 		pg_raise_conn_error( rb_ePGerror, self, "%s", PQerrorMessage(conn));
 	}
 	return Qnil;
@@ -3761,7 +3813,11 @@ pgconn_loopen(int argc, VALUE *argv, VALUE self)
 	else
 		mode = NUM2INT(nmode);
 
-	if((fd = lo_open(conn, lo_oid, mode)) < 0) {
+	BLOCKING_BEGIN(conn)
+		fd = lo_open(conn, lo_oid, mode);
+	BLOCKING_END(conn)
+
+	if(fd < 0) {
 		pg_raise_conn_error( rb_ePGerror, self, "can't open large object: %s", PQerrorMessage(conn));
 	}
 	return INT2FIX(fd);
@@ -3786,8 +3842,12 @@ pgconn_lowrite(VALUE self, VALUE in_lo_desc, VALUE buffer)
 	if( RSTRING_LEN(buffer) < 0) {
 		pg_raise_conn_error( rb_ePGerror, self, "write buffer zero string");
 	}
-	if((n = lo_write(conn, fd, StringValuePtr(buffer),
-				RSTRING_LEN(buffer))) < 0) {
+	BLOCKING_BEGIN(conn)
+		n = lo_write(conn, fd, StringValuePtr(buffer),
+				RSTRING_LEN(buffer));
+	BLOCKING_END(conn)
+
+	if(n < 0) {
 		pg_raise_conn_error( rb_ePGerror, self, "lo_write failed: %s", PQerrorMessage(conn));
 	}
 
@@ -3815,7 +3875,12 @@ pgconn_loread(VALUE self, VALUE in_lo_desc, VALUE in_len)
 		pg_raise_conn_error( rb_ePGerror, self, "negative length %d given", len);
 
 	buffer = ALLOC_N(char, len);
-	if((ret = lo_read(conn, lo_desc, buffer, len)) < 0)
+
+	BLOCKING_BEGIN(conn)
+		ret = lo_read(conn, lo_desc, buffer, len);
+	BLOCKING_END(conn)
+
+	if(ret < 0)
 		pg_raise_conn_error( rb_ePGerror, self, "lo_read failed");
 
 	if(ret == 0) {
@@ -3845,7 +3910,11 @@ pgconn_lolseek(VALUE self, VALUE in_lo_desc, VALUE offset, VALUE whence)
 	int lo_desc = NUM2INT(in_lo_desc);
 	int ret;
 
-	if((ret = lo_lseek(conn, lo_desc, NUM2INT(offset), NUM2INT(whence))) < 0) {
+	BLOCKING_BEGIN(conn)
+		ret = lo_lseek(conn, lo_desc, NUM2INT(offset), NUM2INT(whence));
+	BLOCKING_END(conn)
+
+	if(ret < 0) {
 		pg_raise_conn_error( rb_ePGerror, self, "lo_lseek failed");
 	}
 
@@ -3865,7 +3934,11 @@ pgconn_lotell(VALUE self, VALUE in_lo_desc)
 	PGconn *conn = pg_get_pgconn(self);
 	int lo_desc = NUM2INT(in_lo_desc);
 
-	if((position = lo_tell(conn, lo_desc)) < 0)
+	BLOCKING_BEGIN(conn)
+		position = lo_tell(conn, lo_desc);
+	BLOCKING_END(conn)
+
+	if(position < 0)
 		pg_raise_conn_error( rb_ePGerror, self, "lo_tell failed");
 
 	return INT2FIX(position);
@@ -3883,8 +3956,13 @@ pgconn_lotruncate(VALUE self, VALUE in_lo_desc, VALUE in_len)
 	PGconn *conn = pg_get_pgconn(self);
 	int lo_desc = NUM2INT(in_lo_desc);
 	size_t len = NUM2INT(in_len);
+	int ret;
+
+	BLOCKING_BEGIN(conn)
+		ret = lo_truncate(conn,lo_desc,len);
+	BLOCKING_END(conn)
 
-	if(lo_truncate(conn,lo_desc,len) < 0)
+	if(ret < 0)
 		pg_raise_conn_error( rb_ePGerror, self, "lo_truncate failed");
 
 	return Qnil;
@@ -3901,8 +3979,13 @@ pgconn_loclose(VALUE self, VALUE in_lo_desc)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	int lo_desc = NUM2INT(in_lo_desc);
+	int ret;
+
+	BLOCKING_BEGIN(conn)
+		ret = lo_close(conn,lo_desc);
+	BLOCKING_END(conn)
 
-	if(lo_close(conn,lo_desc) < 0)
+	if(ret < 0)
 		pg_raise_conn_error( rb_ePGerror, self, "lo_close failed");
 
 	return Qnil;
@@ -3919,8 +4002,13 @@ pgconn_lounlink(VALUE self, VALUE in_oid)
 {
 	PGconn *conn = pg_get_pgconn(self);
 	Oid oid = NUM2UINT(in_oid);
+	int ret;
+
+	BLOCKING_BEGIN(conn)
+		ret = lo_unlink(conn,oid);
+	BLOCKING_END(conn)
 
-	if(lo_unlink(conn,oid) < 0)
+	if(ret < 0)
 		pg_raise_conn_error( rb_ePGerror, self, "lo_unlink failed");
 
 	return Qnil;
@@ -3978,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;
@@ -4032,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);
@@ -4084,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 )
@@ -4113,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;
 }
@@ -4153,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;
 }
@@ -4192,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;
 }
@@ -4240,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;
 }
@@ -4292,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;