pg 1.1.3 → 1.3.3

data/ext/pg_text_decoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_decoder.c - PG::TextDecoder module
- * $Id: pg_text_decoder.c,v cee615e0ea2c 2018/07/30 05:27:05 lars $
+ * $Id$
  *
  */
 
@@ -30,7 +30,7 @@
 
 #include "ruby/version.h"
 #include "pg.h"
-#include "util.h"
+#include "pg_util.h"
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
@@ -89,7 +89,7 @@ pg_text_dec_boolean(t_pg_coder *conv, const char *val, int len, int tuple, int f
 VALUE
 pg_text_dec_string(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
-	VALUE ret = rb_tainted_str_new( val, len );
+	VALUE ret = rb_str_new( val, len );
 	PG_ENCODING_SET_NOCHECK( ret, enc_idx );
 	return ret;
 }
@@ -204,7 +204,12 @@ struct pg_blob_initialization {
 
 static VALUE pg_create_blob(VALUE v) {
 	struct pg_blob_initialization *bi = (struct pg_blob_initialization *)v;
-	return rb_tainted_str_new(bi->blob_string, bi->length);
+	return rb_str_new(bi->blob_string, bi->length);
+}
+
+static VALUE pg_pq_freemem(VALUE mem) {
+  PQfreemem((void *)mem);
+  return Qfalse;
 }
 
 /*
@@ -223,7 +228,7 @@ pg_text_dec_bytea(t_pg_coder *conv, const char *val, int len, int tuple, int fie
 	if (bi.blob_string == NULL) {
 		rb_raise(rb_eNoMemError, "PQunescapeBytea failure: probably not enough memory");
 	}
-	return rb_ensure(pg_create_blob, (VALUE)&bi, (VALUE(*)())PQfreemem, (VALUE)bi.blob_string);
+	return rb_ensure(pg_create_blob, (VALUE)&bi, pg_pq_freemem, (VALUE)bi.blob_string);
 }
 
 /*
@@ -558,7 +563,7 @@ pg_text_dec_from_base64(t_pg_coder *conv, const char *val, int len, int tuple, i
 	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, this->comp.format);
 	int decoded_len;
 	/* create a buffer of the expected decoded length */
-	VALUE out_value = rb_tainted_str_new(NULL, BASE64_DECODED_SIZE(len));
+	VALUE out_value = rb_str_new(NULL, BASE64_DECODED_SIZE(len));
 
 	decoded_len = base64_decode( RSTRING_PTR(out_value), val, len );
 	rb_str_set_len(out_value, decoded_len);
@@ -610,7 +615,7 @@ static int parse_year(const char **str) {
  * This is a decoder class for conversion of PostgreSQL text timestamps
  * to Ruby Time objects.
  *
- * The following flags can be used to specify timezone interpretation:
+ * The following flags can be used to specify time interpretation when no timezone is given:
  * * +PG::Coder::TIMESTAMP_DB_UTC+ : Interpret timestamp as UTC time (default)
  * * +PG::Coder::TIMESTAMP_DB_LOCAL+ : Interpret timestamp as local time
  * * +PG::Coder::TIMESTAMP_APP_UTC+ : Return timestamp as UTC time (default)
@@ -619,6 +624,7 @@ static int parse_year(const char **str) {
  * Example:
  *   deco = PG::TextDecoder::Timestamp.new(flags: PG::Coder::TIMESTAMP_DB_UTC | PG::Coder::TIMESTAMP_APP_LOCAL)
  *   deco.decode("2000-01-01 00:00:00")  # => 2000-01-01 01:00:00 +0100
+ *   deco.decode("2000-01-01 00:00:00.123-06")  # => 2000-01-01 00:00:00 -0600
  */
 static VALUE pg_text_dec_timestamp(t_pg_coder *conv, const char *val, int len, int tuple, int field, int enc_idx)
 {
@@ -848,7 +854,7 @@ pg_text_dec_inet(t_pg_coder *conv, const char *val, int len, int tuple, int fiel
 
 		ip_int_native = read_nbo32(dst);
 
-		/* Work around broken IPAddr behavior of convering portion
+		/* Work around broken IPAddr behavior of converting portion
 		   of address after netmask to 0 */
 		switch (mask) {
 			case 0:
@@ -961,7 +967,7 @@ init_pg_text_decoder()
 	pg_define_coder( "Integer", pg_text_dec_integer, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Float", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Float", pg_text_dec_float, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
-	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "BigDecimal", rb_cPG_SimpleDecoder ); */
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Numeric", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "Numeric", pg_text_dec_numeric, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "String", rb_cPG_SimpleDecoder ); */
 	pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );

data/ext/pg_text_encoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_encoder.c - PG::TextEncoder module
- * $Id: pg_text_encoder.c,v e57f6b452eb3 2018/08/18 10:58:52 lars $
+ * $Id$
  *
  */
 
@@ -41,7 +41,7 @@
 
 
 #include "pg.h"
-#include "util.h"
+#include "pg_util.h"
 #ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
 #endif
@@ -50,6 +50,9 @@
 VALUE rb_mPG_TextEncoder;
 static ID s_id_encode;
 static ID s_id_to_i;
+static ID s_id_to_s;
+static ID s_cBigDecimal;
+static VALUE s_str_F;
 
 static int pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx);
 
@@ -125,11 +128,29 @@ pg_coder_enc_to_s(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate,
 	return -1;
 }
 
+static int
+count_leading_zero_bits(unsigned long long x)
+{
+#if defined(__GNUC__) || defined(__clang__)
+	return __builtin_clzll(x);
+#elif defined(_MSC_VER)
+	DWORD r = 0;
+	_BitScanForward64(&r, x);
+	return (int)r;
+#else
+	unsigned int a;
+	for(a=0; a < sizeof(unsigned long long) * 8; a++){
+		if( x & (1 << (sizeof(unsigned long long) * 8 - 1))) return a;
+		x <<= 1;
+	}
+	return a;
+#endif
+}
 
 /*
  * Document-class: PG::TextEncoder::Integer < PG::SimpleEncoder
  *
- * This is the encoder class for the PostgreSQL int types.
+ * This is the encoder class for the PostgreSQL integer types.
  *
  * Non-Integer values are expected to have method +to_i+ defined.
  *
@@ -144,20 +165,23 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 			char *start = out;
 			int len;
 			int neg = 0;
-			long long ll = NUM2LL(*intermediate);
+			long long sll = NUM2LL(*intermediate);
+			unsigned long long ll;
 
-			if (ll < 0) {
-				/* We don't expect problems with the most negative integer not being representable
-				 * as a positive integer, because Fixnum is only up to 63 bits.
+			if (sll < 0) {
+				/* Avoid problems with the most negative integer not being representable
+				 * as a positive integer, by using unsigned long long for encoding.
 				 */
-				ll = -ll;
+				ll = -sll;
 				neg = 1;
+			} else {
+				ll = sll;
 			}
 
 			/* Compute the result string backwards. */
 			do {
-				long long remainder;
-				long long oldval = ll;
+				unsigned long long remainder;
+				unsigned long long oldval = ll;
 
 				ll /= 10;
 				remainder = oldval - ll * 10;
@@ -167,7 +191,7 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 			if (neg)
 				*out++ = '-';
 
-			len = out - start;
+			len = (int)(out - start);
 
 			/* Reverse string. */
 			out--;
@@ -184,45 +208,17 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 	}else{
 		*intermediate = pg_obj_to_i(value);
 		if(TYPE(*intermediate) == T_FIXNUM){
-			int len;
 			long long sll = NUM2LL(*intermediate);
-			long long ll = sll < 0 ? -sll : sll;
-			if( ll < 100000000 ){
-				if( ll < 10000 ){
-					if( ll < 100 ){
-						len = ll < 10 ? 1 : 2;
-					}else{
-						len = ll < 1000 ? 3 : 4;
-					}
-				}else{
-					if( ll < 1000000 ){
-						len = ll < 100000 ? 5 : 6;
-					}else{
-						len = ll < 10000000 ? 7 : 8;
-					}
-				}
-			}else{
-				if( ll < 1000000000000LL ){
-					if( ll < 10000000000LL ){
-						len = ll < 1000000000LL ? 9 : 10;
-					}else{
-						len = ll < 100000000000LL ? 11 : 12;
-					}
-				}else{
-					if( ll < 100000000000000LL ){
-						len = ll < 10000000000000LL ? 13 : 14;
-					}else{
-						return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate, enc_idx);
-					}
-				}
-			}
-			return sll < 0 ? len+1 : len;
+			unsigned long long ll = sll < 0 ? -sll : sll;
+			int len = (sizeof(unsigned long long) * 8 - count_leading_zero_bits(ll)) / 3;
+			return sll < 0 ? len+2 : len+1;
 		}else{
 			return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate, enc_idx);
 		}
 	}
 }
 
+#define MAX_DOUBLE_DIGITS 16
 
 /*
  * Document-class: PG::TextEncoder::Float < PG::SimpleEncoder
@@ -235,6 +231,12 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 {
 	if(out){
 		double dvalue = NUM2DBL(value);
+		int len = 0;
+		int neg = 0;
+		int exp2i, exp10i, i;
+		unsigned long long ll, remainder, oldval;
+		VALUE intermediate;
+
 		/* Cast to the same strings as value.to_s . */
 		if( isinf(dvalue) ){
 			if( dvalue < 0 ){
@@ -248,12 +250,128 @@ pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 			memcpy( out, "NaN", 3);
 			return 3;
 		}
-		return sprintf( out, "%.16E", dvalue);
+
+		/*
+		 * The following computation is roughly a conversion kind of
+		 *   sprintf( out, "%.16E", dvalue);
+		 */
+
+		/* write the algebraic sign */
+		if( dvalue < 0 ) {
+			dvalue = -dvalue;
+			*out++ = '-';
+			neg++;
+		}
+
+		/* retrieve the power of 2 exponent */
+		frexp(dvalue, &exp2i);
+		/* compute the power of 10 exponent */
+		exp10i = (int)floor(exp2i * 0.30102999566398114); /* Math.log(2)/Math.log(10) */
+		/* move the decimal point, so that we get an integer of MAX_DOUBLE_DIGITS decimal digits */
+		ll = (unsigned long long)(dvalue * pow(10, MAX_DOUBLE_DIGITS - 1 - exp10i) + 0.5);
+
+		/* avoid leading zeros due to inaccuracy of deriving exp10i from exp2i */
+		/* otherwise we would print "09.0" instead of "9.0" */
+		if( ll < 1000000000000000 ){ /* pow(10, MAX_DOUBLE_DIGITS-1) */
+			exp10i--;
+			ll *= 10;
+		}
+
+		if( exp10i <= -5 || exp10i >= 15 ) {
+			/* Write the float in exponent format (1.23e45) */
+
+			/* write fraction digits from right to left */
+			for( i = MAX_DOUBLE_DIGITS; i > 1; i--){
+				oldval = ll;
+				ll /= 10;
+				remainder = oldval - ll * 10;
+				/* omit trailing zeros */
+				if(remainder != 0 || len ) {
+					out[i] = '0' + remainder;
+					len++;
+				}
+			}
+
+			/* write decimal point */
+			if( len ){
+				out[1] = '.';
+				len++;
+			}
+
+			/* write remaining single digit left to the decimal point */
+			oldval = ll;
+			ll /= 10;
+			remainder = oldval - ll * 10;
+			out[0] = '0' + remainder;
+			len++;
+
+			/* write exponent */
+			out[len++] = 'e';
+			intermediate = INT2NUM(exp10i);
+
+			return neg + len + pg_text_enc_integer(conv, Qnil, out + len, &intermediate, enc_idx);
+		} else {
+			/* write the float in non exponent format (0.001234 or 123450.0) */
+
+			/* write digits from right to left */
+			int lz = exp10i < 0 ? 0 : exp10i;
+			for( i = MAX_DOUBLE_DIGITS - (exp10i < 0 ? exp10i : 0); i >= 0; i-- ){
+				oldval = ll;
+				ll /= 10;
+				remainder = oldval - ll * 10;
+				/* write decimal point */
+				if( i - 1 == lz ){
+					out[i--] = '.';
+					len++;
+				}
+				/* if possible then omit trailing zeros */
+				if(remainder != 0 || len || i - 2 == lz) {
+					out[i] = '0' + remainder;
+					len++;
+				}
+			}
+			return neg + len;
+		}
 	}else{
-		return 23;
+		return 1 /*sign*/ + MAX_DOUBLE_DIGITS + 1 /*dot*/ + 1 /*e*/ + 1 /*exp sign*/ + 3 /*exp digits*/;
+	}
+}
+
+
+/*
+ * Document-class: PG::TextEncoder::Numeric < PG::SimpleEncoder
+ *
+ * This is the encoder class for the PostgreSQL numeric types.
+ *
+ * It converts Integer, Float and BigDecimal objects.
+ * All other objects are expected to respond to +to_s+.
+ */
+static int
+pg_text_enc_numeric(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
+{
+	switch(TYPE(value)){
+		case T_FIXNUM:
+		case T_BIGNUM:
+			return pg_text_enc_integer(this, value, out, intermediate, enc_idx);
+		case T_FLOAT:
+			return pg_text_enc_float(this, value, out, intermediate, enc_idx);
+		default:
+			if(out){ /* second pass */
+				rb_bug("unexpected value type: %d", TYPE(value));
+			} else { /* first pass */
+				if( rb_obj_is_kind_of(value, s_cBigDecimal) ){
+					/* value.to_s('F') */
+					*intermediate = rb_funcall(value, s_id_to_s, 1, s_str_F);
+					return -1; /* no second pass */
+				} else {
+					return pg_coder_enc_to_s(this, value, NULL, intermediate, enc_idx);
+					/* no second pass */
+				}
+			}
 	}
 }
 
+
 static const char hextab[] = {
 	'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
 };
@@ -261,8 +379,7 @@ static const char hextab[] = {
 /*
  * Document-class: PG::TextEncoder::Bytea < PG::SimpleEncoder
  *
- * This is an encoder class for the PostgreSQL bytea type for server version 9.0
- * or newer.
+ * This is an encoder class for the PostgreSQL +bytea+ type.
  *
  * The binary String is converted to hexadecimal representation for transmission
  * in text format. For query bind parameters it is recommended to use
@@ -286,11 +403,11 @@ pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate,
 			*optr++ = hextab[c >> 4];
 			*optr++ = hextab[c & 0xf];
 		}
-		return optr - out;
+		return (int)(optr - out);
 	}else{
 		*intermediate = rb_obj_as_string(value);
 		/* The output starts with "\x" and each character is converted to hex. */
-		return 2 + RSTRING_LEN(*intermediate) * 2;
+		return 2 + RSTRING_LENINT(*intermediate) * 2;
 	}
 }
 
@@ -493,8 +610,8 @@ quote_identifier( VALUE value, VALUE out_string, char *current_out ){
 static char *
 pg_text_enc_array_identifier(VALUE value, VALUE string, char *out, int enc_idx)
 {
-	int i;
-	int nr_elems;
+	long i;
+	long nr_elems;
 
 	Check_Type(value, T_ARRAY);
 	nr_elems = RARRAY_LEN(value);
@@ -520,7 +637,8 @@ pg_text_enc_array_identifier(VALUE value, VALUE string, char *out, int enc_idx)
  *
  * This is the encoder class for PostgreSQL identifiers.
  *
- * An Array value can be used for "schema.table.column" type identifiers:
+ * An Array value can be used for identifiers of the kind "schema.table.column".
+ * This ensures that each element is properly quoted:
  *   PG::TextEncoder::Identifier.new.encode(['schema', 'table', 'column'])
  *      => '"schema"."table"."column"'
  *
@@ -588,7 +706,13 @@ quote_literal_buffer( void *_this, char *p_in, int strlen, char *p_out ){
  *
  * This is the encoder class for PostgreSQL literals.
  *
- * A literal is quoted and escaped by the +'+ character.
+ * A literal is quoted and escaped by the <tt>'</tt> character, so that it can be inserted into SQL queries.
+ * It works equal to PG::Connection#escape_literal, but integrates into the type cast system of ruby-pg.
+ *
+ * Both expressions have the same result:
+ *   conn.escape_literal(PG::TextEncoder::Array.new.encode(["v1","v2"])) # => "'{v1,v2}'"
+ *   PG::TextEncoder::QuotedLiteral.new(elements_type: PG::TextEncoder::Array.new).encode(["v1","v2"]) # => "'{v1,v2}'"
+ * While escape_literal requires a intermediate ruby string allocation, QuotedLiteral encodes the values directly to the result string.
  *
  */
 static int
@@ -655,6 +779,12 @@ init_pg_text_encoder()
 {
 	s_id_encode = rb_intern("encode");
 	s_id_to_i = rb_intern("to_i");
+	s_id_to_s = rb_intern("to_s");
+	s_str_F = rb_str_freeze(rb_str_new_cstr("F"));
+	rb_global_variable(&s_str_F);
+	rb_require("bigdecimal");
+	s_cBigDecimal = rb_const_get(rb_cObject, rb_intern("BigDecimal"));
+
 
 	/* This module encapsulates all encoder classes with text output format */
 	rb_mPG_TextEncoder = rb_define_module_under( rb_mPG, "TextEncoder" );
@@ -666,6 +796,8 @@ init_pg_text_encoder()
 	pg_define_coder( "Integer", pg_text_enc_integer, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Float", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "Float", pg_text_enc_float, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Numeric", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Numeric", pg_text_enc_numeric, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "String", rb_cPG_SimpleEncoder ); */
 	pg_define_coder( "String", pg_coder_enc_to_s, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
 	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Bytea", rb_cPG_SimpleEncoder ); */

data/ext/pg_tuple.c

@@ -52,57 +52,83 @@ typedef struct {
 	VALUE values[0];
 } t_pg_tuple;
 
-static inline VALUE
-pg_tuple_get_field_names( t_pg_tuple *this )
+static inline VALUE *
+pg_tuple_get_field_names_ptr( t_pg_tuple *this )
 {
 	if( this->num_fields != (int)RHASH_SIZE(this->field_map) ){
-		return this->values[this->num_fields];
+		return &this->values[this->num_fields];
 	} else {
-		return Qfalse;
+		static VALUE f = Qfalse;
+		return &f;
+	}
+}
+
+static inline VALUE
+pg_tuple_get_field_names( t_pg_tuple *this )
+{
+	return *pg_tuple_get_field_names_ptr(this);
+}
+
+static void
+pg_tuple_gc_mark( void *_this )
+{
+	t_pg_tuple *this = (t_pg_tuple *)_this;
+	int i;
+
+	if( !this ) return;
+	rb_gc_mark_movable( this->result );
+	rb_gc_mark_movable( this->typemap );
+	rb_gc_mark_movable( this->field_map );
+
+	for( i = 0; i < this->num_fields; i++ ){
+		rb_gc_mark_movable( this->values[i] );
 	}
+	rb_gc_mark_movable( pg_tuple_get_field_names(this) );
 }
 
 static void
-pg_tuple_gc_mark( t_pg_tuple *this )
+pg_tuple_gc_compact( void *_this )
 {
+	t_pg_tuple *this = (t_pg_tuple *)_this;
 	int i;
 
 	if( !this ) return;
-	rb_gc_mark( this->result );
-	rb_gc_mark( this->typemap );
-	rb_gc_mark( this->field_map );
+	pg_gc_location( this->result );
+	pg_gc_location( this->typemap );
+	pg_gc_location( this->field_map );
 
 	for( i = 0; i < this->num_fields; i++ ){
-		rb_gc_mark( this->values[i] );
+		pg_gc_location( this->values[i] );
 	}
-	rb_gc_mark( pg_tuple_get_field_names(this) );
+	pg_gc_location( *pg_tuple_get_field_names_ptr(this) );
 }
 
 static void
-pg_tuple_gc_free( t_pg_tuple *this )
+pg_tuple_gc_free( void *_this )
 {
+	t_pg_tuple *this = (t_pg_tuple *)_this;
 	if( !this ) return;
 	xfree(this);
 }
 
 static size_t
-pg_tuple_memsize( t_pg_tuple *this )
+pg_tuple_memsize( const void *_this )
 {
+	const t_pg_tuple *this = (const t_pg_tuple *)_this;
 	if( this==NULL ) return 0;
 	return sizeof(*this) +  sizeof(*this->values) * this->num_fields;
 }
 
 static const rb_data_type_t pg_tuple_type = {
-	"pg",
+	"PG::Tuple",
 	{
-		(void (*)(void*))pg_tuple_gc_mark,
-		(void (*)(void*))pg_tuple_gc_free,
-		(size_t (*)(const void *))pg_tuple_memsize,
+		pg_tuple_gc_mark,
+		pg_tuple_gc_free,
+		pg_tuple_memsize,
+		pg_compact_callback(pg_tuple_gc_compact),
 	},
 	0, 0,
-#ifdef RUBY_TYPED_FREE_IMMEDIATELY
 	RUBY_TYPED_FREE_IMMEDIATELY,
-#endif
 };
 
 /*
@@ -132,7 +158,6 @@ pg_tuple_new(VALUE result, int row_num)
 		sizeof(*this) +
 		sizeof(*this->values) * num_fields +
 		sizeof(*this->values) * (dup_names ? 1 : 0));
-	RTYPEDDATA_DATA(self) = this;
 
 	this->result = result;
 	this->typemap = p_result->typemap;
@@ -151,6 +176,8 @@ pg_tuple_new(VALUE result, int row_num)
 		this->values[num_fields] = rb_obj_freeze(rb_ary_new4(num_fields, p_result->fnames));
 	}
 
+	RTYPEDDATA_DATA(self) = this;
+
 	return self;
 }
 
@@ -171,7 +198,7 @@ pg_tuple_materialize_field(t_pg_tuple *this, int col)
 	VALUE value = this->values[col];
 
 	if( value == Qundef ){
-		t_typemap *p_typemap = DATA_PTR( this->typemap );
+		t_typemap *p_typemap = RTYPEDDATA_DATA( this->typemap );
 
 		pgresult_get(this->result); /* make sure we have a valid PGresult object */
 		value = p_typemap->funcs.typecast_result_value(p_typemap, this->result, this->row_num, col);
@@ -211,7 +238,7 @@ pg_tuple_materialize(t_pg_tuple *this)
  * An integer +key+ is interpreted as column index.
  * Negative values of index count from the end of the array.
  *
- * A string +key+ is interpreted as column name.
+ * Depending on Result#field_name_type= a string or symbol +key+ is interpreted as column name.
  *
  * If the key can't be found, there are several options:
  * With no other arguments, it will raise a IndexError exception;
@@ -264,9 +291,16 @@ pg_tuple_fetch(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *    res[ name ] -> value
+ *    tup[ key ] -> value
+ *
+ * Returns a field value by either column index or column name.
+ *
+ * An integer +key+ is interpreted as column index.
+ * Negative values of index count from the end of the array.
  *
- * Returns field _name_.
+ * Depending on Result#field_name_type= a string or symbol +key+ is interpreted as column name.
+ *
+ * If the key can't be found, it returns +nil+ .
  */
 static VALUE
 pg_tuple_aref(VALUE self, VALUE key)
@@ -457,7 +491,6 @@ pg_tuple_load(VALUE self, VALUE a)
 	int dup_names;
 
 	rb_check_frozen(self);
-	rb_check_trusted(self);
 
 	TypedData_Get_Struct(self, t_pg_tuple, &pg_tuple_type, this);
 	if (this)
@@ -472,9 +505,9 @@ pg_tuple_load(VALUE self, VALUE a)
 	rb_obj_freeze(field_names);
 	values = RARRAY_AREF(a, 1);
 	Check_Type(values, T_ARRAY);
-	num_fields = RARRAY_LEN(values);
+	num_fields = RARRAY_LENINT(values);
 
-	if (RARRAY_LEN(field_names) != num_fields)
+	if (RARRAY_LENINT(field_names) != num_fields)
 		rb_raise(rb_eTypeError, "different number of fields and values");
 
 	field_map = rb_hash_new();
@@ -489,7 +522,6 @@ pg_tuple_load(VALUE self, VALUE a)
 		sizeof(*this) +
 		sizeof(*this->values) * num_fields +
 		sizeof(*this->values) * (dup_names ? 1 : 0));
-	RTYPEDDATA_DATA(self) = this;
 
 	this->result = Qnil;
 	this->typemap = Qnil;
@@ -508,6 +540,8 @@ pg_tuple_load(VALUE self, VALUE a)
 		this->values[num_fields] = field_names;
 	}
 
+	RTYPEDDATA_DATA(self) = this;
+
 	if (FL_TEST(a, FL_EXIVAR)) {
 		rb_copy_generic_ivar(self, a);
 		FL_SET(self, FL_EXIVAR);