pg 0.17.1-x64-mingw32 → 0.18.0.pre20141017160319-x64-mingw32

data/ext/pg_text_decoder.c

@@ -0,0 +1,424 @@
+/*
+ * pg_text_decoder.c - PG::TextDecoder module
+ * $Id$
+ *
+ */
+
+/*
+ *
+ * Type casts for decoding PostgreSQL string representations to Ruby objects.
+ *
+ * Decoder classes are defined with pg_define_coder(). This creates a new coder class and
+ * assigns a decoder function.
+ *
+ * Signature of all type cast decoders is:
+ *    VALUE decoder_function(t_pg_coder *this, char *val, int len, int tuple, int field, int enc_idx)
+ *
+ * Params:
+ *   this     - The data part of the coder object that belongs to the decoder function.
+ *   val, len - The text or binary data to decode. The caller ensures, that the data is
+ *              zero terminated ( that is val[len] = 0 ). The memory should be used read
+ *              only by the callee.
+ *   tuple    - Row of the value within the result set.
+ *   field    - Column of the value within the result set.
+ *   enc_idx  - Index of the Encoding that any output String should get assigned.
+ *
+ * Returns:
+ *   The type casted Ruby object.
+ *
+ */
+
+#include "pg.h"
+#include "util.h"
+#include <inttypes.h>
+
+VALUE rb_mPG_TextDecoder;
+static ID s_id_decode;
+
+
+/*
+ * Document-class: PG::TextDecoder::Boolean < PG::SimpleDecoder
+ *
+ * This is a decoder class for conversion of PostgreSQL boolean type
+ * to Ruby true or false values.
+ *
+ */
+static VALUE
+pg_text_dec_boolean(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	if (len < 1) {
+		rb_raise( rb_eTypeError, "wrong data for text boolean converter in tuple %d field %d", tuple, field);
+	}
+	return *val == 't' ? Qtrue : Qfalse;
+}
+
+/*
+ * Document-class: PG::TextDecoder::String < PG::SimpleDecoder
+ *
+ * This is a decoder class for conversion of PostgreSQL text output to
+ * to Ruby String object. The output value will have the character encoding
+ * set with PG::Connection#internal_encoding= .
+ *
+ */
+VALUE
+pg_text_dec_string(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	VALUE ret = rb_tainted_str_new( val, len );
+	PG_ENCODING_SET_NOCHECK( ret, enc_idx );
+	return ret;
+}
+
+/*
+ * Document-class: PG::TextDecoder::Integer < PG::SimpleDecoder
+ *
+ * This is a decoder class for conversion of PostgreSQL integer types
+ * to Ruby Integer objects.
+ *
+ */
+static VALUE
+pg_text_dec_integer(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	long i;
+	int max_len;
+
+	if( sizeof(i) >= 8 && FIXNUM_MAX >= 1000000000000000000LL ){
+		/* 64 bit system can safely handle all numbers up to 18 digits as Fixnum */
+		max_len = 18;
+	} else if( sizeof(i) >= 4 && FIXNUM_MAX >= 1000000000LL ){
+		/* 32 bit system can safely handle all numbers up to 9 digits as Fixnum */
+		max_len = 9;
+	} else {
+		/* unknown -> don't use fast path for int conversion */
+		max_len = 0;
+	}
+
+	if( len <= max_len ){
+		/* rb_cstr2inum() seems to be slow, so we do the int conversion by hand.
+		 * This proved to be 40% faster by the following benchmark:
+		 *
+		 *   conn.type_mapping_for_results = PG::BasicTypeMapForResults.new conn
+		 *   Benchmark.measure do
+		 *     conn.exec("select generate_series(1,1000000)").values }
+		 *   end
+		 */
+		char *val_pos = val;
+		char digit = *val_pos;
+		int neg;
+		int error = 0;
+
+		if( digit=='-' ){
+			neg = 1;
+			i = 0;
+		}else if( digit>='0' && digit<='9' ){
+			neg = 0;
+			i = digit - '0';
+		} else {
+			error = 1;
+		}
+
+		while (!error && (digit=*++val_pos)) {
+			if( digit>='0' && digit<='9' ){
+				i = i * 10 + (digit - '0');
+			} else {
+				error = 1;
+			}
+		}
+
+		if( !error ){
+			return LONG2FIX(neg ? -i : i);
+		}
+	}
+	/* Fallback to ruby method if number too big or unrecognized. */
+	return rb_cstr2inum(val, 10);
+}
+
+/*
+ * Document-class: PG::TextDecoder::Float < PG::SimpleDecoder
+ *
+ * This is a decoder class for conversion of PostgreSQL float4 and float8 types
+ * to Ruby Float objects.
+ *
+ */
+static VALUE
+pg_text_dec_float(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	return rb_float_new(strtod(val, NULL));
+}
+
+/*
+ * Document-class: PG::TextDecoder::Bytea < PG::SimpleDecoder
+ *
+ * This is a decoder class for conversion of PostgreSQL bytea type
+ * to binary String objects.
+ *
+ */
+static VALUE
+pg_text_dec_bytea(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	unsigned char *to;
+	size_t to_len;
+	VALUE ret;
+
+	to = PQunescapeBytea( (unsigned char *)val, &to_len);
+
+	ret = rb_tainted_str_new((char*)to, to_len);
+	PQfreemem(to);
+
+	return ret;
+}
+
+/*
+ * Array parser functions are thankfully borrowed from here:
+ * https://github.com/dockyard/pg_array_parser
+ */
+static VALUE
+read_array(t_pg_composite_coder *this, int *index, char *c_pg_array_string, int array_string_length, char *word, int enc_idx, int tuple, int field, t_pg_coder_dec_func dec_func)
+{
+	/* Return value: array */
+	VALUE array;
+	int word_index = 0;
+
+	/* The current character in the input string. */
+	char c;
+
+	/*  0: Currently outside a quoted string, current word never quoted
+	*  1: Currently inside a quoted string
+	* -1: Currently outside a quoted string, current word previously quoted */
+	int openQuote = 0;
+
+	/* Inside quoted input means the next character should be treated literally,
+	* instead of being treated as a metacharacter.
+	* Outside of quoted input, means that the word shouldn't be pushed to the array,
+	* used when the last entry was a subarray (which adds to the array itself). */
+	int escapeNext = 0;
+
+	array = rb_ary_new();
+
+	/* Special case the empty array, so it doesn't need to be handled manually inside
+	* the loop. */
+	if(((*index) < array_string_length) && c_pg_array_string[(*index)] == '}')
+	{
+		return array;
+	}
+
+	for(;(*index) < array_string_length; ++(*index))
+	{
+		c = c_pg_array_string[*index];
+		if(openQuote < 1)
+		{
+			if(c == this->delimiter || c == '}')
+			{
+				if(!escapeNext)
+				{
+					if(openQuote == 0 && word_index == 4 && !strncmp(word, "NULL", word_index))
+					{
+						rb_ary_push(array, Qnil);
+					}
+					else
+					{
+						VALUE val;
+						word[word_index] = 0;
+						val = dec_func(this->elem, word, word_index, tuple, field, enc_idx);
+						rb_ary_push(array, val);
+					}
+				}
+				if(c == '}')
+				{
+					return array;
+				}
+				escapeNext = 0;
+				openQuote = 0;
+				word_index = 0;
+			}
+			else if(c == '"')
+			{
+				openQuote = 1;
+			}
+			else if(c == '{')
+			{
+				(*index)++;
+				rb_ary_push(array, read_array(this, index, c_pg_array_string, array_string_length, word, enc_idx, tuple, field, dec_func));
+				escapeNext = 1;
+			}
+			else
+			{
+				word[word_index] = c;
+				word_index++;
+			}
+		}
+		else if (escapeNext) {
+			word[word_index] = c;
+			word_index++;
+			escapeNext = 0;
+		}
+		else if (c == '\\')
+		{
+			escapeNext = 1;
+		}
+		else if (c == '"')
+		{
+			openQuote = -1;
+		}
+		else
+		{
+			word[word_index] = c;
+			word_index++;
+		}
+	}
+
+	return array;
+}
+
+/*
+ * Document-class: PG::TextDecoder::Array < PG::CompositeDecoder
+ *
+ * This is the decoder class for PostgreSQL array types.
+ *
+ * All values are decoded according to the #elements_type
+ * accessor. Sub-arrays are decoded recursively.
+ *
+ */
+static VALUE
+pg_text_dec_array(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, 0);
+	/* create a buffer of the same length, as that will be the worst case */
+	char *word = xmalloc(len + 1);
+	int index = 1;
+
+	VALUE return_value = read_array(this, &index, val, len, word, enc_idx, tuple, field, dec_func);
+	free(word);
+	return return_value;
+}
+
+/*
+ * Document-class: PG::TextDecoder::Identifier < PG::CompositeDecoder
+ *
+ * This is the decoder class for PostgreSQL identifiers.
+ *
+ * Returns an Array of identifiers:
+ *   PG::TextDecoder::Identifier.new.decode('schema."table"."column"')
+ *      => ["schema", "table", "column"]
+ *
+ */
+static VALUE
+pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+	t_pg_coder_dec_func dec_func = pg_coder_dec_func(this->elem, 0);
+
+	/* Return value: array */
+	VALUE array;
+	VALUE elem;
+	int word_index = 0;
+	int index;
+	/* create a buffer of the same length, as that will be the worst case */
+	char *word = xmalloc(len + 1);
+
+	/* The current character in the input string. */
+	char c;
+
+	/*  0: Currently outside a quoted string
+	*  1: Currently inside a quoted string, last char was a quote
+	*  2: Currently inside a quoted string, last char was no quote */
+	int openQuote = 0;
+
+	array = rb_ary_new();
+
+	for(index = 0; index < len; ++index) {
+		c = val[index];
+		if(c == '.' && openQuote < 2 ) {
+			word[word_index] = 0;
+
+			elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
+			rb_ary_push(array, elem);
+
+			openQuote = 0;
+			word_index = 0;
+		} else if(c == '"') {
+			if (openQuote == 1) {
+				word[word_index] = c;
+				word_index++;
+				openQuote = 2;
+			} else if (openQuote == 2){
+				openQuote = 1;
+			} else {
+				openQuote = 2;
+			}
+		} else {
+			word[word_index] = c;
+			word_index++;
+		}
+	}
+
+	word[word_index] = 0;
+	elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
+	rb_ary_push(array, elem);
+
+	free(word);
+
+	return array;
+}
+
+/*
+ * Document-class: PG::TextDecoder::FromBase64 < PG::CompositeDecoder
+ *
+ * This is a decoder class for conversion of base64 encoded data
+ * to it's binary representation. It outputs a binary Ruby String
+ * or some other Ruby object, if a #elements_type decoder was defined.
+ *
+ */
+static VALUE
+pg_text_dec_from_base64(t_pg_coder *conv, char *val, int len, int tuple, int field, int enc_idx)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+	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));
+
+	decoded_len = base64_decode( RSTRING_PTR(out_value), val, len );
+	rb_str_set_len(out_value, decoded_len);
+
+	/* Is it a pure String conversion? Then we can directly send out_value to the user. */
+	if( this->comp.format == 0 && dec_func == pg_text_dec_string ){
+		PG_ENCODING_SET_NOCHECK( out_value, enc_idx );
+		return out_value;
+	}
+	if( this->comp.format == 1 && dec_func == pg_bin_dec_bytea ){
+		PG_ENCODING_SET_NOCHECK( out_value, rb_ascii8bit_encindex() );
+		return out_value;
+	}
+	out_value = dec_func(this->elem, RSTRING_PTR(out_value), decoded_len, tuple, field, enc_idx);
+
+	return out_value;
+}
+
+void
+init_pg_text_decoder()
+{
+	s_id_decode = rb_intern("decode");
+
+	/* This module encapsulates all decoder classes with text input format */
+	rb_mPG_TextDecoder = rb_define_module_under( rb_mPG, "TextDecoder" );
+
+	/* Make RDoc aware of the decoder classes... */
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Boolean", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Boolean", pg_text_dec_boolean, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Integer", rb_cPG_SimpleDecoder ); */
+	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, "String", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "String", pg_text_dec_string, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Bytea", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Bytea", pg_text_dec_bytea, rb_cPG_SimpleDecoder, rb_mPG_TextDecoder );
+
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Array", rb_cPG_CompositeDecoder ); */
+	pg_define_coder( "Array", pg_text_dec_array, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "Identifier", rb_cPG_CompositeDecoder ); */
+	pg_define_coder( "Identifier", pg_text_dec_identifier, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextDecoder, "FromBase64", rb_cPG_CompositeDecoder ); */
+	pg_define_coder( "FromBase64", pg_text_dec_from_base64, rb_cPG_CompositeDecoder, rb_mPG_TextDecoder );
+}

data/ext/pg_text_encoder.c

@@ -0,0 +1,631 @@
+/*
+ * pg_text_encoder.c - PG::TextEncoder module
+ * $Id$
+ *
+ */
+
+/*
+ *
+ * Type casts for encoding Ruby objects to PostgreSQL string representations.
+ *
+ * Encoder classes are defined with pg_define_coder(). This creates a new coder class and
+ * assigns an encoder function. The encoder function can decide between two different options
+ * to return the encoded data. It can either return it as a Ruby String object or write the
+ * encoded data to a memory space provided by the caller. In the second case, the encoder
+ * function is called twice, once for deciding the encoding option and returning the expected
+ * data length, and a second time when the requested memory space was made available by the
+ * calling function, to do the actual conversion and writing. Parameter intermediate can be
+ * used to store data between these two calls.
+ *
+ * Signature of all type cast encoders is:
+ *    int encoder_function(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+ *
+ * Params:
+ *   this  - The data part of the coder object that belongs to the encoder function.
+ *   value - The Ruby object to cast.
+ *   out   - NULL for the first call,
+ *           pointer to a buffer with the requested size for the second call.
+ *   intermediate - Pointer to a VALUE that might be set by the encoding function to some
+ *           value in the first call that can be retrieved later in the second call.
+ *           This VALUE is not yet initialized by the caller.
+ *
+ * Returns:
+ *   >= 0  - If out==NULL the encoder function must return the expected output buffer size.
+ *           This can be larger than the size of the second call, but may not be smaller.
+ *           If out!=NULL the encoder function must return the actually used output buffer size
+ *           without a termination character.
+ *   -1    - The encoder function can alternatively return -1 to indicate that no second call
+ *           is required, but the String value in *intermediate should be used instead.
+ */
+
+
+#include "pg.h"
+#include "util.h"
+#include <inttypes.h>
+
+VALUE rb_mPG_TextEncoder;
+static ID s_id_encode;
+static ID s_id_to_i;
+static VALUE hash_false_values;
+
+
+VALUE
+pg_obj_to_i( VALUE value )
+{
+	switch (TYPE(value)) {
+		case T_FIXNUM:
+		case T_FLOAT:
+		case T_BIGNUM:
+			return value;
+		default:
+			return rb_funcall(value, s_id_to_i, 0);
+	}
+}
+
+/*
+ * Document-class: PG::TextEncoder::Boolean < PG::SimpleEncoder
+ *
+ * This is the encoder class for the PostgreSQL bool type.
+ *
+ * Ruby values false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off' and 'OFF'
+ * are encoded as SQL +FALSE+ value. nil is sent as SQL +NULL+.
+ * Any other values are encoded as SQL +TRUE+ .
+ *
+ */
+static int
+pg_text_enc_boolean(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	if(out){
+		switch( TYPE(value) ){
+			case T_FALSE:
+				*out = 'f';
+				break;
+			case T_FIXNUM:
+			case T_BIGNUM:
+				if( NUM2LONG(value) == 0 ){
+					*out = 'f';
+				} else {
+					*out = 't';
+				}
+				break;
+			case T_STRING:
+				if( rb_hash_lookup(hash_false_values, value) == Qtrue ){
+					*out = 'f';
+					break;
+				}
+				/* fall through */
+			default:
+				*out = 't';
+		}
+	}
+	return 1;
+}
+
+
+/*
+ * Document-class: PG::TextEncoder::String < PG::SimpleEncoder
+ *
+ * This is the encoder class for the PostgreSQL text types.
+ *
+ * Non-String values are expected to have method +to_s+ defined.
+ *
+ */
+int
+pg_coder_enc_to_s(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+{
+	*intermediate = rb_obj_as_string(value);
+	return -1;
+}
+
+
+/*
+ * Document-class: PG::TextEncoder::Integer < PG::SimpleEncoder
+ *
+ * This is the encoder class for the PostgreSQL int types.
+ *
+ * Non-Integer values are expected to have method +to_i+ defined.
+ *
+ */
+static int
+pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+{
+	if(out){
+		if(TYPE(*intermediate) == T_STRING){
+			return pg_coder_enc_to_s(this, value, out, intermediate);
+		}else{
+			char *start = out;
+			int len;
+			int neg = 0;
+			long long ll = NUM2LL(*intermediate);
+
+			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.
+				 */
+				ll = -ll;
+				neg = 1;
+			}
+
+			/* Compute the result string backwards. */
+			do {
+				long long remainder;
+				long long oldval = ll;
+
+				ll /= 10;
+				remainder = oldval - ll * 10;
+				*out++ = '0' + remainder;
+			} while (ll != 0);
+
+			if (neg)
+				*out++ = '-';
+
+			len = out - start;
+
+			/* Reverse string. */
+			out--;
+			while (start < out)
+			{
+				char swap = *start;
+
+				*start++ = *out;
+				*out-- = swap;
+			}
+
+			return len;
+		}
+	}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);
+					}
+				}
+			}
+			return sll < 0 ? len+1 : len;
+		}else{
+			return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate);
+		}
+	}
+}
+
+
+/*
+ * Document-class: PG::TextEncoder::Float < PG::SimpleEncoder
+ *
+ * This is the encoder class for the PostgreSQL float types.
+ *
+ */
+static int
+pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	if(out){
+		double dvalue = NUM2DBL(value);
+		/* Cast to the same strings as value.to_s . */
+		if( isinf(dvalue) ){
+			if( dvalue < 0 ){
+				memcpy( out, "-Infinity", 9);
+				return 9;
+			} else {
+				memcpy( out, "Infinity", 8);
+				return 8;
+			}
+		} else if (isnan(dvalue)) {
+			memcpy( out, "NaN", 3);
+			return 3;
+		}
+		return sprintf( out, "%.16E", dvalue);
+	}else{
+		return 23;
+	}
+}
+
+typedef int (*t_quote_func)( void *_this, char *p_in, int strlen, char *p_out );
+
+static int
+quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
+	t_pg_composite_coder *this = _this;
+	char *ptr1;
+	char *ptr2;
+	int backslashs = 0;
+	int needquote;
+
+	/* count data plus backslashes; detect chars needing quotes */
+	if (strlen == 0)
+		needquote = 1;   /* force quotes for empty string */
+	else if (strlen == 4 && pg_strncasecmp(p_in, "NULL", strlen) == 0)
+		needquote = 1;   /* force quotes for literal NULL */
+	else
+		needquote = 0;
+
+	/* count required backlashs */
+	for(ptr1 = p_in; ptr1 != p_in + strlen; ptr1++) {
+		char ch = *ptr1;
+
+		if (ch == '"' || ch == '\\'){
+			needquote = 1;
+			backslashs++;
+		} else if (ch == '{' || ch == '}' || ch == this->delimiter ||
+					ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' || ch == '\v' || ch == '\f'){
+			needquote = 1;
+		}
+	}
+
+	if( needquote ){
+		ptr1 = p_in + strlen;
+		ptr2 = p_out + strlen + backslashs + 2;
+		/* Write end quote */
+		*--ptr2 = '"';
+
+		/* Then store the escaped string on the final position, walking
+			* right to left, until all backslashs are placed. */
+		while( ptr1 != p_in ) {
+			*--ptr2 = *--ptr1;
+			if(*ptr2 == '"' || *ptr2 == '\\'){
+				*--ptr2 = '\\';
+			}
+		}
+		/* Write start quote */
+		*p_out = '"';
+		return strlen + backslashs + 2;
+	} else {
+		if( p_in != p_out )
+			memcpy( p_out, p_in, strlen );
+		return strlen;
+	}
+}
+
+static char *
+quote_string(t_pg_coder *this, VALUE value, VALUE string, char *current_out, int with_quote, t_quote_func quote_buffer, void *func_data)
+{
+	int strlen;
+	VALUE subint;
+	t_pg_coder_enc_func enc_func = pg_coder_enc_func(this);
+
+	strlen = enc_func(this, value, NULL, &subint);
+
+	if( strlen == -1 ){
+		/* we can directly use String value in subint */
+		strlen = RSTRING_LENINT(subint);
+
+		if(with_quote){
+			/* size of string assuming the worst case, that every character must be escaped. */
+			current_out = pg_rb_str_ensure_capa( string, strlen * 2 + 2, current_out, NULL );
+
+			current_out += quote_buffer( func_data, RSTRING_PTR(subint), strlen, current_out );
+		} else {
+			current_out = pg_rb_str_ensure_capa( string, strlen, current_out, NULL );
+			memcpy( current_out, RSTRING_PTR(subint), strlen );
+			current_out += strlen;
+		}
+
+	} else {
+
+		if(with_quote){
+			/* size of string assuming the worst case, that every character must be escaped
+			 * plus two bytes for quotation.
+			 */
+			current_out = pg_rb_str_ensure_capa( string, 2 * strlen + 2, current_out, NULL );
+
+			/* Place the unescaped string at current output position. */
+			strlen = enc_func(this, value, current_out, &subint);
+
+			current_out += quote_buffer( func_data, current_out, strlen, current_out );
+		}else{
+			/* size of the unquoted string */
+			current_out = pg_rb_str_ensure_capa( string, strlen, current_out, NULL );
+			current_out += enc_func(this, value, current_out, &subint);
+		}
+	}
+	return current_out;
+}
+
+static char *
+write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE string, int quote)
+{
+	int i;
+
+	/* size of "{}" */
+	current_out = pg_rb_str_ensure_capa( string, 2, current_out, NULL );
+	*current_out++ = '{';
+
+	for( i=0; i<RARRAY_LEN(value); i++){
+		VALUE entry = rb_ary_entry(value, i);
+
+		if( i > 0 ){
+			current_out = pg_rb_str_ensure_capa( string, 1, current_out, NULL );
+			*current_out++ = this->delimiter;
+		}
+
+		switch(TYPE(entry)){
+			case T_ARRAY:
+				current_out = write_array(this, entry, current_out, string, quote);
+			break;
+			case T_NIL:
+				current_out = pg_rb_str_ensure_capa( string, 4, current_out, NULL );
+				*current_out++ = 'N';
+				*current_out++ = 'U';
+				*current_out++ = 'L';
+				*current_out++ = 'L';
+				break;
+			default:
+				current_out = quote_string( this->elem, entry, string, current_out, quote, quote_array_buffer, this );
+		}
+	}
+	current_out = pg_rb_str_ensure_capa( string, 1, current_out, NULL );
+	*current_out++ = '}';
+	return current_out;
+}
+
+
+/*
+ * Document-class: PG::TextEncoder::Array < PG::CompositeEncoder
+ *
+ * This is the encoder class for PostgreSQL array types.
+ *
+ * All values are encoded according to the #elements_type
+ * accessor. Sub-arrays are encoded recursively.
+ *
+ * This encoder expects an Array of values or sub-arrays as input.
+ * Other values are passed through as text without interpretation.
+ *
+ */
+static int
+pg_text_enc_array(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	char *end_ptr;
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+
+	if( TYPE(value) == T_ARRAY){
+		*intermediate = rb_str_new(NULL, 0);
+
+		end_ptr = write_array(this, value, RSTRING_PTR(*intermediate), *intermediate, this->needs_quotation);
+
+		rb_str_set_len( *intermediate, end_ptr - RSTRING_PTR(*intermediate) );
+
+		return -1;
+	} else {
+		return pg_coder_enc_to_s( conv, value, out, intermediate );
+	}
+}
+
+static int
+quote_identifier_buffer( void *_this, char *p_in, int strlen, char *p_out ){
+	char *ptr1;
+	char *ptr2;
+	int backslashs = 0;
+
+	/* count required backlashs */
+	for(ptr1 = p_in; ptr1 != p_in + strlen; ptr1++) {
+		if (*ptr1 == '"'){
+			backslashs++;
+		}
+	}
+
+	ptr1 = p_in + strlen;
+	ptr2 = p_out + strlen + backslashs + 2;
+	/* Write end quote */
+	*--ptr2 = '"';
+
+	/* Then store the escaped string on the final position, walking
+		* right to left, until all backslashs are placed. */
+	while( ptr1 != p_in ) {
+		*--ptr2 = *--ptr1;
+		if(*ptr2 == '"'){
+			*--ptr2 = '"';
+		}
+	}
+	/* Write start quote */
+	*p_out = '"';
+	return strlen + backslashs + 2;
+}
+
+static char *
+pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE string, char *out)
+{
+	int i;
+	int nr_elems;
+
+	Check_Type(value, T_ARRAY);
+	nr_elems = RARRAY_LEN(value);
+
+	for( i=0; i<nr_elems; i++){
+		VALUE entry = rb_ary_entry(value, i);
+
+		out = quote_string(this->elem, entry, string, out, this->needs_quotation, quote_identifier_buffer, this);
+		if( i < nr_elems-1 ){
+			out = pg_rb_str_ensure_capa( string, 1, out, NULL );
+			*out++ = '.';
+		}
+	}
+	return out;
+}
+
+/*
+ * Document-class: PG::TextEncoder::Identifier < PG::CompositeEncoder
+ *
+ * This is the encoder class for PostgreSQL identifiers.
+ *
+ * An Array value can be used for "schema.table.column" type identifiers:
+ *   PG::TextEncoder::Identifier.new.encode(['schema', 'table', 'column'])
+ *      => "schema"."table"."column"
+ *
+ */
+static int
+pg_text_enc_identifier(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+
+	*intermediate = rb_str_new(NULL, 0);
+	out = RSTRING_PTR(*intermediate);
+
+	if( TYPE(value) == T_ARRAY){
+		out = pg_text_enc_array_identifier(this, value, *intermediate, out);
+	} else {
+		out = quote_string(this->elem, value, *intermediate, out, this->needs_quotation, quote_identifier_buffer, this);
+	}
+	rb_str_set_len( *intermediate, out - RSTRING_PTR(*intermediate) );
+	return -1;
+}
+
+
+static int
+quote_literal_buffer( void *_this, char *p_in, int strlen, char *p_out ){
+	char *ptr1;
+	char *ptr2;
+	int backslashs = 0;
+
+	/* count required backlashs */
+	for(ptr1 = p_in; ptr1 != p_in + strlen; ptr1++) {
+		if (*ptr1 == '\''){
+			backslashs++;
+		}
+	}
+
+	ptr1 = p_in + strlen;
+	ptr2 = p_out + strlen + backslashs + 2;
+	/* Write end quote */
+	*--ptr2 = '\'';
+
+	/* Then store the escaped string on the final position, walking
+		* right to left, until all backslashs are placed. */
+	while( ptr1 != p_in ) {
+		*--ptr2 = *--ptr1;
+		if(*ptr2 == '\''){
+			*--ptr2 = '\'';
+		}
+	}
+	/* Write start quote */
+	*p_out = '\'';
+	return strlen + backslashs + 2;
+}
+
+
+/*
+ * Document-class: PG::TextEncoder::QuotedLiteral < PG::CompositeEncoder
+ *
+ * This is the encoder class for PostgreSQL literals.
+ *
+ * A literal is quoted and escaped by the +'+ character.
+ *
+ */
+static int
+pg_text_enc_quoted_literal(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+
+	*intermediate = rb_str_new(NULL, 0);
+	out = RSTRING_PTR(*intermediate);
+	out = quote_string(this->elem, value, *intermediate, out, this->needs_quotation, quote_literal_buffer, this);
+	rb_str_set_len( *intermediate, out - RSTRING_PTR(*intermediate) );
+	return -1;
+}
+
+/*
+ * Document-class: PG::TextEncoder::ToBase64 < PG::CompositeEncoder
+ *
+ * This is an encoder class for conversion of binary to base64 data.
+ *
+ */
+static int
+pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+{
+	int strlen;
+	VALUE subint;
+	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+	t_pg_coder_enc_func enc_func = pg_coder_enc_func(this->elem);
+
+	if(out){
+		/* Second encoder pass, if required */
+		strlen = enc_func(this->elem, value, out, intermediate);
+		base64_encode( out, out, strlen );
+
+		return BASE64_ENCODED_SIZE(strlen);
+	} else {
+		/* First encoder pass */
+		strlen = enc_func(this->elem, value, NULL, &subint);
+
+		if( strlen == -1 ){
+			/* Encoded string is returned in subint */
+			VALUE out_str;
+
+			strlen = RSTRING_LENINT(subint);
+			out_str = rb_str_new(NULL, BASE64_ENCODED_SIZE(strlen));
+
+			base64_encode( RSTRING_PTR(out_str), RSTRING_PTR(subint), strlen);
+			*intermediate = out_str;
+
+			return -1;
+		} else {
+			*intermediate = subint;
+
+			return BASE64_ENCODED_SIZE(strlen);
+		}
+	}
+}
+
+
+void
+init_pg_text_encoder()
+{
+	s_id_encode = rb_intern("encode");
+	s_id_to_i = rb_intern("to_i");
+
+	hash_false_values = rb_hash_new();
+	rb_gc_register_address( &hash_false_values );
+	rb_hash_aset( hash_false_values, rb_str_new2( "0" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "f" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "F" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "false" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "FALSE" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "off" ), Qtrue );
+	rb_hash_aset( hash_false_values, rb_str_new2( "OFF" ), Qtrue );
+
+	/* This module encapsulates all encoder classes with text output format */
+	rb_mPG_TextEncoder = rb_define_module_under( rb_mPG, "TextEncoder" );
+
+	/* Make RDoc aware of the encoder classes... */
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Boolean", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Boolean", pg_text_enc_boolean, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Integer", rb_cPG_SimpleEncoder ); */
+	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, "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, "Array", rb_cPG_CompositeEncoder ); */
+	pg_define_coder( "Array", pg_text_enc_array, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Identifier", rb_cPG_CompositeEncoder ); */
+	pg_define_coder( "Identifier", pg_text_enc_identifier, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "QuotedLiteral", rb_cPG_CompositeEncoder ); */
+	pg_define_coder( "QuotedLiteral", pg_text_enc_quoted_literal, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "ToBase64", rb_cPG_CompositeEncoder ); */
+	pg_define_coder( "ToBase64", pg_text_enc_to_base64, rb_cPG_CompositeEncoder, rb_mPG_TextEncoder );
+}