pg 0.18.1 → 0.19.0

data/ext/pg_copy_coder.c

@@ -167,9 +167,15 @@ pg_copycoder_type_map_get(VALUE self)
  *     conn.put_copy_data ["string2", 42, true]
  *   end
  * This creates +my_table+ and inserts two rows.
+ *
+ * It is possible to manually assign a type encoder for each column per PG::TypeMapByColumn,
+ * or to make use of PG::BasicTypeMapBasedOnResult to assign them based on the table OIDs.
+ *
+ * See also PG::TextDecoder::CopyRow for the decoding direction with
+ * PG::Connection#get_copy_data .
  */
 static int
-pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	t_pg_copycoder *this = (t_pg_copycoder *)conv;
 	t_pg_coder_enc_func enc_func;
@@ -184,6 +190,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 
 	/* Allocate a new string with embedded capacity and realloc exponential when needed. */
 	PG_RB_STR_NEW( *intermediate, current_out, end_capa_ptr );
+	PG_ENCODING_SET_NOCHECK(*intermediate, enc_idx);
 
 	for( i=0; i<RARRAY_LEN(value); i++){
 		char *ptr1;
@@ -211,7 +218,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 				enc_func = pg_coder_enc_func(p_elem_coder);
 
 				/* 1st pass for retiving the required memory space */
-				strlen = enc_func(p_elem_coder, entry, NULL, &subint);
+				strlen = enc_func(p_elem_coder, entry, NULL, &subint, enc_idx);
 
 				if( strlen == -1 ){
 					/* we can directly use String value in subint */
@@ -234,7 +241,7 @@ pg_text_enc_copy_row(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedia
 					PG_RB_STR_ENSURE_CAPA( *intermediate, strlen * 2, current_out, end_capa_ptr );
 
 					/* Place the unescaped string at current output position. */
-					strlen = enc_func(p_elem_coder, entry, current_out, &subint);
+					strlen = enc_func(p_elem_coder, entry, current_out, &subint, enc_idx);
 
 					ptr1 = current_out;
 					ptr2 = current_out + strlen;
@@ -301,15 +308,38 @@ GetDecimalFromHex(char hex)
  * strings by PG::TextDecoder::String.
  *
  * Example with default type map ( TypeMapAllStrings ):
+ *   conn.exec("CREATE TABLE my_table AS VALUES('astring', 7, FALSE), ('string2', 42, TRUE) ")
+ *
  *   deco = PG::TextDecoder::CopyRow.new
  *   conn.copy_data "COPY my_table TO STDOUT", deco do
  *     while row=conn.get_copy_data
  *       p row
  *     end
  *   end
- * This prints all rows of +my_table+ to stdout:
+ * This prints all rows of +my_table+ :
  *   ["astring", "7", "f"]
  *   ["string2", "42", "t"]
+ *
+ * Example with column based type map:
+ *   tm = PG::TypeMapByColumn.new( [
+ *     PG::TextDecoder::String.new,
+ *     PG::TextDecoder::Integer.new,
+ *     PG::TextDecoder::Boolean.new] )
+ *   deco = PG::TextDecoder::CopyRow.new( type_map: tm )
+ *   conn.copy_data "COPY my_table TO STDOUT", deco do
+ *     while row=conn.get_copy_data
+ *       p row
+ *     end
+ *   end
+ * This prints the rows with type casted columns:
+ *   ["astring", 7, false]
+ *   ["string2", 42, true]
+ *
+ * Instead of manually assigning a type decoder for each column, PG::BasicTypeMapForResults
+ * can be used to assign them based on the table OIDs.
+ *
+ * See also PG::TextEncoder::CopyRow for the encoding direction with
+ * PG::Connection#put_copy_data .
  */
 /*
  * Parse the current line into separate attributes (fields),

data/ext/pg_result.c

@@ -1,6 +1,6 @@
 /*
  * pg_result.c - PG::Result class extension
- * $Id: pg_result.c,v f23dd01bcb52 2014/11/17 10:47:53 kanis $
+ * $Id: pg_result.c,v 982082c0d77b 2016/01/31 19:28:55 ged $
  *
  */
 
@@ -288,7 +288,7 @@ static void pgresult_init_fnames(VALUE self)
  *
  * Example:
  *    require 'pg'
- *    conn = PGconn.open(:dbname => 'test')
+ *    conn = PG.connect(:dbname => 'test')
  *    res  = conn.exec('SELECT 1 AS a, 2 AS b, NULL AS c')
  *    res.getvalue(0,0) # '1'
  *    res[0]['b']       # '2'
@@ -863,7 +863,7 @@ pgresult_each_row(VALUE self)
 	num_fields = PQnfields(this->pgresult);
 
 	for ( row = 0; row < num_rows; row++ ) {
-		VALUE row_values[num_fields];
+		PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, num_fields, PG_MAX_COLUMNS)
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
@@ -892,7 +892,7 @@ pgresult_values(VALUE self)
 	VALUE results = rb_ary_new2( num_rows );
 
 	for ( row = 0; row < num_rows; row++ ) {
-		VALUE row_values[num_fields];
+		PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, num_fields, PG_MAX_COLUMNS)
 
 		/* populate the row */
 		for ( field = 0; field < num_fields; field++ ) {
@@ -1176,7 +1176,7 @@ pgresult_stream_each_row(VALUE self)
 		}
 
 		for ( row = 0; row < ntuples; row++ ) {
-			VALUE row_values[nfields];
+			PG_VARIABLE_LENGTH_ARRAY(VALUE, row_values, nfields, PG_MAX_COLUMNS)
 			int field;
 
 			/* populate the row */

data/ext/pg_text_decoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_decoder.c - PG::TextDecoder module
- * $Id: pg_text_decoder.c,v b7f9daeeba29 2014/11/21 19:53:47 lars $
+ * $Id: pg_text_decoder.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
  *
  */
 
@@ -30,7 +30,9 @@
 
 #include "pg.h"
 #include "util.h"
+#ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
+#endif
 
 VALUE rb_mPG_TextDecoder;
 static ID s_id_decode;
@@ -293,7 +295,7 @@ pg_text_dec_array(t_pg_coder *conv, char *val, int len, int tuple, int field, in
 }
 
 /*
- * Document-class: PG::TextDecoder::Identifier < PG::CompositeDecoder
+ * Document-class: PG::TextDecoder::Identifier < PG::SimpleDecoder
  *
  * This is the decoder class for PostgreSQL identifiers.
  *
@@ -305,16 +307,13 @@ pg_text_dec_array(t_pg_coder *conv, char *val, int len, int tuple, int field, in
 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;
 	/* Use a buffer of the same length, as that will be the worst case */
-	char word[len + 1];
+	PG_VARIABLE_LENGTH_ARRAY(char, word, len + 1, NAMEDATALEN)
 
 	/* The current character in the input string. */
 	char c;
@@ -331,7 +330,7 @@ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int fiel
 		if(c == '.' && openQuote < 2 ) {
 			word[word_index] = 0;
 
-			elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
+			elem = pg_text_dec_string(conv, word, word_index, tuple, field, enc_idx);
 			rb_ary_push(array, elem);
 
 			openQuote = 0;
@@ -353,7 +352,7 @@ pg_text_dec_identifier(t_pg_coder *conv, char *val, int len, int tuple, int fiel
 	}
 
 	word[word_index] = 0;
-	elem = dec_func(conv, word, word_index, tuple, field, enc_idx);
+	elem = pg_text_dec_string(conv, word, word_index, tuple, field, enc_idx);
 	rb_ary_push(array, elem);
 
 	return array;
@@ -412,11 +411,11 @@ init_pg_text_decoder()
 	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, "Identifier", rb_cPG_SimpleDecoder ); */
+	pg_define_coder( "Identifier", pg_text_dec_identifier, 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

@@ -1,6 +1,6 @@
 /*
  * pg_text_encoder.c - PG::TextEncoder module
- * $Id: pg_text_encoder.c,v 1a13e7eafeb7 2014/12/12 20:57:39 lars $
+ * $Id: pg_text_encoder.c,v e61a06f1f5ed 2015/12/25 21:14:21 lars $
  *
  */
 
@@ -28,6 +28,7 @@
  *   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.
+ *   enc_idx  - Index of the output Encoding that strings should be converted to.
  *
  * Returns:
  *   >= 0  - If out==NULL the encoder function must return the expected output buffer size.
@@ -41,14 +42,16 @@
 
 #include "pg.h"
 #include "util.h"
+#ifdef HAVE_INTTYPES_H
 #include <inttypes.h>
+#endif
 #include <math.h>
 
 VALUE rb_mPG_TextEncoder;
 static ID s_id_encode;
 static ID s_id_to_i;
 
-static int pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate);
+static int pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx);
 
 VALUE
 pg_obj_to_i( VALUE value )
@@ -74,7 +77,7 @@ pg_obj_to_i( VALUE value )
  *
  */
 static int
-pg_text_enc_boolean(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_boolean(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	switch( TYPE(value) ){
 		case T_FALSE:
@@ -92,10 +95,10 @@ pg_text_enc_boolean(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 				if(out) *out = '1';
 				return 1;
 			} else {
-				return pg_text_enc_integer(this, value, out, intermediate);
+				return pg_text_enc_integer(this, value, out, intermediate, enc_idx);
 			}
 		default:
-			return pg_coder_enc_to_s(this, value, out, intermediate);
+			return pg_coder_enc_to_s(this, value, out, intermediate, enc_idx);
 	}
 	/* never reached */
 	return 0;
@@ -111,9 +114,14 @@ pg_text_enc_boolean(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
  *
  */
 int
-pg_coder_enc_to_s(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+pg_coder_enc_to_s(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
-	*intermediate = rb_obj_as_string(value);
+	VALUE str = rb_obj_as_string(value);
+	if( ENCODING_GET(str) == enc_idx ){
+		*intermediate = str;
+	}else{
+		*intermediate = rb_str_export_to_enc(str, rb_enc_from_index(enc_idx));
+	}
 	return -1;
 }
 
@@ -127,11 +135,11 @@ pg_coder_enc_to_s(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
  *
  */
 static int
-pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		if(TYPE(*intermediate) == T_STRING){
-			return pg_coder_enc_to_s(this, value, out, intermediate);
+			return pg_coder_enc_to_s(this, value, out, intermediate, enc_idx);
 		}else{
 			char *start = out;
 			int len;
@@ -204,13 +212,13 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
 					if( ll < 100000000000000LL ){
 						len = ll < 10000000000000LL ? 13 : 14;
 					}else{
-						return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate);
+						return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate, enc_idx);
 					}
 				}
 			}
 			return sll < 0 ? len+1 : len;
 		}else{
-			return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate);
+			return pg_coder_enc_to_s(this, *intermediate, NULL, intermediate, enc_idx);
 		}
 	}
 }
@@ -223,7 +231,7 @@ pg_text_enc_integer(t_pg_coder *this, VALUE value, char *out, VALUE *intermediat
  *
  */
 static int
-pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_float(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		double dvalue = NUM2DBL(value);
@@ -263,7 +271,7 @@ static const char hextab[] = {
  *
  */
 static int
-pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_bytea(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	if(out){
 		size_t strlen = RSTRING_LEN(*intermediate);
@@ -299,7 +307,7 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 	/* 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)
+	else if (strlen == 4 && rbpg_strncasecmp(p_in, "NULL", strlen) == 0)
 		needquote = 1;   /* force quotes for literal NULL */
 	else
 		needquote = 0;
@@ -342,13 +350,13 @@ quote_array_buffer( void *_this, char *p_in, int strlen, char *p_out ){
 }
 
 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)
+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 enc_idx)
 {
 	int strlen;
 	VALUE subint;
 	t_pg_coder_enc_func enc_func = pg_coder_enc_func(this);
 
-	strlen = enc_func(this, value, NULL, &subint);
+	strlen = enc_func(this, value, NULL, &subint, enc_idx);
 
 	if( strlen == -1 ){
 		/* we can directly use String value in subint */
@@ -374,20 +382,20 @@ quote_string(t_pg_coder *this, VALUE value, VALUE string, char *current_out, int
 			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);
+			strlen = enc_func(this, value, current_out, &subint, enc_idx);
 
 			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);
+			current_out += enc_func(this, value, current_out, &subint, enc_idx);
 		}
 	}
 	return current_out;
 }
 
 static char *
-write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE string, int quote)
+write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE string, int quote, int enc_idx)
 {
 	int i;
 
@@ -405,7 +413,7 @@ write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE st
 
 		switch(TYPE(entry)){
 			case T_ARRAY:
-				current_out = write_array(this, entry, current_out, string, quote);
+				current_out = write_array(this, entry, current_out, string, quote, enc_idx);
 			break;
 			case T_NIL:
 				current_out = pg_rb_str_ensure_capa( string, 4, current_out, NULL );
@@ -415,7 +423,7 @@ write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE st
 				*current_out++ = 'L';
 				break;
 			default:
-				current_out = quote_string( this->elem, entry, string, current_out, quote, quote_array_buffer, this );
+				current_out = quote_string( this->elem, entry, string, current_out, quote, quote_array_buffer, this, enc_idx );
 		}
 	}
 	current_out = pg_rb_str_ensure_capa( string, 1, current_out, NULL );
@@ -437,57 +445,54 @@ write_array(t_pg_composite_coder *this, VALUE value, char *current_out, VALUE st
  *
  */
 static int
-pg_text_enc_array(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_array(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	char *end_ptr;
 	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
 
 	if( TYPE(value) == T_ARRAY){
-		*intermediate = rb_str_new(NULL, 0);
+		VALUE out_str = rb_str_new(NULL, 0);
+		PG_ENCODING_SET_NOCHECK(out_str, enc_idx);
 
-		end_ptr = write_array(this, value, RSTRING_PTR(*intermediate), *intermediate, this->needs_quotation);
+		end_ptr = write_array(this, value, RSTRING_PTR(out_str), out_str, this->needs_quotation, enc_idx);
 
-		rb_str_set_len( *intermediate, end_ptr - RSTRING_PTR(*intermediate) );
+		rb_str_set_len( out_str, end_ptr - RSTRING_PTR(out_str) );
+		*intermediate = out_str;
 
 		return -1;
 	} else {
-		return pg_coder_enc_to_s( conv, value, out, intermediate );
+		return pg_coder_enc_to_s( conv, value, out, intermediate, enc_idx );
 	}
 }
 
-static int
-quote_identifier_buffer( void *_this, char *p_in, int strlen, char *p_out ){
+static char *
+quote_identifier( VALUE value, VALUE out_string, char *current_out ){
+	char *p_in = RSTRING_PTR(value);
 	char *ptr1;
-	char *ptr2;
-	int backslashs = 0;
+	size_t strlen = RSTRING_LEN(value);
+	char *end_capa = current_out;
 
-	/* count required backlashs */
+	PG_RB_STR_ENSURE_CAPA( out_string, strlen + 2, current_out, end_capa );
+	*current_out++ = '"';
 	for(ptr1 = p_in; ptr1 != p_in + strlen; ptr1++) {
-		if (*ptr1 == '"'){
-			backslashs++;
+		char c = *ptr1;
+		if (c == '"'){
+			strlen++;
+			PG_RB_STR_ENSURE_CAPA( out_string, p_in - ptr1 + strlen + 1, current_out, end_capa );
+			*current_out++ = '"';
+		} else if (c == 0){
+			break;
 		}
+		*current_out++ = c;
 	}
+	PG_RB_STR_ENSURE_CAPA( out_string, 1, current_out, end_capa );
+	*current_out++ = '"';
 
-	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;
+	return current_out;
 }
 
 static char *
-pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE string, char *out)
+pg_text_enc_array_identifier(VALUE value, VALUE string, char *out, int enc_idx)
 {
 	int i;
 	int nr_elems;
@@ -498,7 +503,11 @@ pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE stri
 	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);
+		StringValue(entry);
+		if( ENCODING_GET(entry) != enc_idx ){
+			entry = rb_str_export_to_enc(entry, rb_enc_from_index(enc_idx));
+		}
+		out = quote_identifier(entry, string, out);
 		if( i < nr_elems-1 ){
 			out = pg_rb_str_ensure_capa( string, 1, out, NULL );
 			*out++ = '.';
@@ -508,29 +517,37 @@ pg_text_enc_array_identifier(t_pg_composite_coder *this, VALUE value, VALUE stri
 }
 
 /*
- * Document-class: PG::TextEncoder::Identifier < PG::CompositeEncoder
+ * Document-class: PG::TextEncoder::Identifier < PG::SimpleEncoder
  *
  * 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"
+ *      => '"schema"."table"."column"'
  *
+ *  This encoder can also be used per PG::Connection#quote_ident .
  */
-static int
-pg_text_enc_identifier(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+int
+pg_text_enc_identifier(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
-	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
-
-	*intermediate = rb_str_new(NULL, 0);
-	out = RSTRING_PTR(*intermediate);
-
+	VALUE out_str;
+	UNUSED( this );
 	if( TYPE(value) == T_ARRAY){
-		out = pg_text_enc_array_identifier(this, value, *intermediate, out);
+		out_str = rb_str_new(NULL, 0);
+		out = RSTRING_PTR(out_str);
+		out = pg_text_enc_array_identifier(value, out_str, out, enc_idx);
 	} else {
-		out = quote_string(this->elem, value, *intermediate, out, this->needs_quotation, quote_identifier_buffer, this);
+		StringValue(value);
+		if( ENCODING_GET(value) != enc_idx ){
+			value = rb_str_export_to_enc(value, rb_enc_from_index(enc_idx));
+		}
+		out_str = rb_str_new(NULL, RSTRING_LEN(value) + 2);
+		out = RSTRING_PTR(out_str);
+		out = quote_identifier(value, out_str, out);
 	}
-	rb_str_set_len( *intermediate, out - RSTRING_PTR(*intermediate) );
+	rb_str_set_len( out_str, out - RSTRING_PTR(out_str) );
+	PG_ENCODING_SET_NOCHECK(out_str, enc_idx);
+	*intermediate = out_str;
 	return -1;
 }
 
@@ -576,14 +593,16 @@ quote_literal_buffer( void *_this, char *p_in, int strlen, char *p_out ){
  *
  */
 static int
-pg_text_enc_quoted_literal(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_quoted_literal(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	t_pg_composite_coder *this = (t_pg_composite_coder *)conv;
+	VALUE out_str = rb_str_new(NULL, 0);
+	PG_ENCODING_SET_NOCHECK(out_str, enc_idx);
 
-	*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) );
+	out = RSTRING_PTR(out_str);
+	out = quote_string(this->elem, value, out_str, out, this->needs_quotation, quote_literal_buffer, this, enc_idx);
+	rb_str_set_len( out_str, out - RSTRING_PTR(out_str) );
+	*intermediate = out_str;
 	return -1;
 }
 
@@ -594,7 +613,7 @@ pg_text_enc_quoted_literal(t_pg_coder *conv, VALUE value, char *out, VALUE *inte
  *
  */
 static int
-pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
 	int strlen;
 	VALUE subint;
@@ -603,13 +622,13 @@ pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedi
 
 	if(out){
 		/* Second encoder pass, if required */
-		strlen = enc_func(this->elem, value, out, intermediate);
+		strlen = enc_func(this->elem, value, out, intermediate, enc_idx);
 		base64_encode( out, out, strlen );
 
 		return BASE64_ENCODED_SIZE(strlen);
 	} else {
 		/* First encoder pass */
-		strlen = enc_func(this->elem, value, NULL, &subint);
+		strlen = enc_func(this->elem, value, NULL, &subint, enc_idx);
 
 		if( strlen == -1 ){
 			/* Encoded string is returned in subint */
@@ -617,6 +636,7 @@ pg_text_enc_to_base64(t_pg_coder *conv, VALUE value, char *out, VALUE *intermedi
 
 			strlen = RSTRING_LENINT(subint);
 			out_str = rb_str_new(NULL, BASE64_ENCODED_SIZE(strlen));
+			PG_ENCODING_SET_NOCHECK(out_str, enc_idx);
 
 			base64_encode( RSTRING_PTR(out_str), RSTRING_PTR(subint), strlen);
 			*intermediate = out_str;
@@ -651,11 +671,11 @@ init_pg_text_encoder()
 	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 ); */
 	pg_define_coder( "Bytea", pg_text_enc_bytea, rb_cPG_SimpleEncoder, rb_mPG_TextEncoder );
+	/* dummy = rb_define_class_under( rb_mPG_TextEncoder, "Identifier", rb_cPG_SimpleEncoder ); */
+	pg_define_coder( "Identifier", pg_text_enc_identifier, 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 ); */