pg 0.18.3 → 1.0.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 1269b8ad77b8 2015/02/06 16:38:23 lars $
+ * $Id: pg_result.c,v 7c5d9608349f 2018/01/03 16:11:52 lars $
  *
  */
 
@@ -92,12 +92,8 @@ pg_result_check( VALUE self )
 		case PGRES_TUPLES_OK:
 		case PGRES_COPY_OUT:
 		case PGRES_COPY_IN:
-#ifdef HAVE_CONST_PGRES_COPY_BOTH
 		case PGRES_COPY_BOTH:
-#endif
-#ifdef HAVE_CONST_PGRES_SINGLE_TUPLE
 		case PGRES_SINGLE_TUPLE:
-#endif
 		case PGRES_EMPTY_QUERY:
 		case PGRES_COMMAND_OK:
 			return self;
@@ -288,7 +284,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'
@@ -302,7 +298,7 @@ static void pgresult_init_fnames(VALUE self)
 
 /*
  * call-seq:
- *    res.result_status() -> Fixnum
+ *    res.result_status() -> Integer
  *
  * Returns the status of the query. The status value is one of:
  * * +PGRES_EMPTY_QUERY+
@@ -414,7 +410,7 @@ pgresult_error_field(VALUE self, VALUE field)
 
 /*
  * call-seq:
- *    res.ntuples() -> Fixnum
+ *    res.ntuples() -> Integer
  *
  * Returns the number of tuples in the query result.
  */
@@ -466,7 +462,7 @@ pgresult_fname(VALUE self, VALUE index)
 
 /*
  * call-seq:
- *    res.fnumber( name ) -> Fixnum
+ *    res.fnumber( name ) -> Integer
  *
  * Returns the index of the field specified by the string +name+.
  * The given +name+ is treated like an identifier in an SQL command, that is,
@@ -527,7 +523,7 @@ pgresult_ftable(VALUE self, VALUE column_number)
 
 /*
  * call-seq:
- *    res.ftablecol( column_number ) -> Fixnum
+ *    res.ftablecol( column_number ) -> Integer
  *
  * Returns the column number (within its table) of the table from
  * which the column _column_number_ is made up.
@@ -552,7 +548,7 @@ pgresult_ftablecol(VALUE self, VALUE column_number)
 
 /*
  * call-seq:
- *    res.fformat( column_number ) -> Fixnum
+ *    res.fformat( column_number ) -> Integer
  *
  * Returns the format (0 for text, 1 for binary) of column
  * _column_number_.
@@ -696,7 +692,7 @@ pgresult_getisnull(VALUE self, VALUE tup_num, VALUE field_num)
 
 /*
  * call-seq:
- *    res.getlength( tup_num, field_num ) -> Fixnum
+ *    res.getlength( tup_num, field_num ) -> Integer
  *
  * Returns the (String) length of the field in bytes.
  *
@@ -721,7 +717,7 @@ pgresult_getlength(VALUE self, VALUE tup_num, VALUE field_num)
 
 /*
  * call-seq:
- *    res.nparams() -> Fixnum
+ *    res.nparams() -> Integer
  *
  * Returns the number of parameters of a prepared statement.
  * Only useful for the result returned by conn.describePrepared
@@ -772,11 +768,17 @@ pgresult_cmd_status(VALUE self)
  * Returns the number of tuples (rows) affected by the SQL command.
  *
  * If the SQL command that generated the PG::Result was not one of:
- * * +INSERT+
- * * +UPDATE+
- * * +DELETE+
- * * +MOVE+
- * * +FETCH+
+ *
+ * * <tt>SELECT</tt>
+ * * <tt>CREATE TABLE AS</tt>
+ * * <tt>INSERT</tt>
+ * * <tt>UPDATE</tt>
+ * * <tt>DELETE</tt>
+ * * <tt>MOVE</tt>
+ * * <tt>FETCH</tt>
+ * * <tt>COPY</tt>
+ * * an +EXECUTE+ of a prepared query that contains an +INSERT+, +UPDATE+, or +DELETE+ statement
+ *
  * or if no tuples were affected, <tt>0</tt> is returned.
  */
 static VALUE
@@ -1050,7 +1052,6 @@ pgresult_type_map_get(VALUE self)
 	return this->typemap;
 }
 
-#ifdef HAVE_PQSETSINGLEROWMODE
 /*
  * call-seq:
  *    res.stream_each{ |tuple| ... }
@@ -1081,6 +1082,8 @@ pgresult_type_map_get(VALUE self)
  *     # do something with the received row of the second query
  *   end
  *   conn.get_result  # => nil   (no more results)
+ *
+ * Available since PostgreSQL-9.2
  */
 static VALUE
 pgresult_stream_each(VALUE self)
@@ -1144,6 +1147,8 @@ pgresult_stream_each(VALUE self)
  *
  * This method works equally to #stream_each , but yields an Array of
  * values.
+ *
+ * Available since PostgreSQL-9.2
  */
 static VALUE
 pgresult_stream_each_row(VALUE self)
@@ -1204,7 +1209,6 @@ pgresult_stream_each_row(VALUE self)
 	/* never reached */
 	return self;
 }
-#endif
 
 
 void
@@ -1261,11 +1265,9 @@ init_pg_result()
 	rb_define_method(rb_cPGresult, "type_map=", pgresult_type_map_set, 1);
 	rb_define_method(rb_cPGresult, "type_map", pgresult_type_map_get, 0);
 
-#ifdef HAVE_PQSETSINGLEROWMODE
 	/******     PG::Result INSTANCE METHODS: streaming     ******/
 	rb_define_method(rb_cPGresult, "stream_each", pgresult_stream_each, 0);
 	rb_define_method(rb_cPGresult, "stream_each_row", pgresult_stream_each_row, 0);
-#endif
 }
 
 

data/ext/pg_text_decoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_decoder.c - PG::TextDecoder module
- * $Id: pg_text_decoder.c,v b111c84b8445 2015/02/11 20:54:03 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;

data/ext/pg_text_encoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_encoder.c - PG::TextEncoder module
- * $Id: pg_text_encoder.c,v b859963462b2 2015/03/13 17:39:35 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);
@@ -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,21 +445,23 @@ 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 );
 	}
 }
 
@@ -482,7 +492,7 @@ quote_identifier( VALUE value, VALUE out_string, char *current_out ){
 }
 
 static char *
-pg_text_enc_array_identifier(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;
@@ -493,6 +503,10 @@ pg_text_enc_array_identifier(VALUE value, VALUE string, char *out)
 	for( i=0; i<nr_elems; i++){
 		VALUE entry = rb_ary_entry(value, i);
 
+		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 );
@@ -514,20 +528,26 @@ pg_text_enc_array_identifier(VALUE value, VALUE string, char *out)
  *  This encoder can also be used per PG::Connection#quote_ident .
  */
 int
-pg_text_enc_identifier(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate)
+pg_text_enc_identifier(t_pg_coder *this, VALUE value, char *out, VALUE *intermediate, int enc_idx)
 {
+	VALUE out_str;
 	UNUSED( this );
 	if( TYPE(value) == T_ARRAY){
-		*intermediate = rb_str_new(NULL, 0);
-		out = RSTRING_PTR(*intermediate);
-		out = pg_text_enc_array_identifier(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 {
 		StringValue(value);
-		*intermediate = rb_str_new(NULL, RSTRING_LEN(value) + 2);
-		out = RSTRING_PTR(*intermediate);
-		out = quote_identifier(value, *intermediate, out);
+		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;
 }
 
@@ -573,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;
 }
 
@@ -591,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;
@@ -600,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 */
@@ -614,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;

data/ext/pg_type_map.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map.c,v c99d26015e3c 2014/12/12 20:58:25 lars $
+ * $Id: pg_type_map.c,v 2af122820861 2017/01/14 19:56:36 lars $
  *
  */
 
@@ -11,55 +11,62 @@ VALUE rb_mDefaultTypeMappable;
 static ID s_id_fit_to_query;
 static ID s_id_fit_to_result;
 
+NORETURN( VALUE
+pg_typemap_fit_to_result( VALUE self, VALUE result ));
+NORETURN( VALUE
+pg_typemap_fit_to_query( VALUE self, VALUE params ));
+NORETURN( int
+pg_typemap_fit_to_copy_get( VALUE self ));
+NORETURN( VALUE
+pg_typemap_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field ));
+NORETURN( t_pg_coder *
+pg_typemap_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field ));
+NORETURN( VALUE
+pg_typemap_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx ));
+
 VALUE
 pg_typemap_fit_to_result( VALUE self, VALUE result )
 {
 	rb_raise( rb_eNotImpError, "type map %s is not suitable to map result values", rb_obj_classname(self) );
-	return Qnil;
 }
 
 VALUE
 pg_typemap_fit_to_query( VALUE self, VALUE params )
 {
 	rb_raise( rb_eNotImpError, "type map %s is not suitable to map query params", rb_obj_classname(self) );
-	return Qnil;
 }
 
 int
 pg_typemap_fit_to_copy_get( VALUE self )
 {
 	rb_raise( rb_eNotImpError, "type map %s is not suitable to map get_copy_data results", rb_obj_classname(self) );
-	return Qnil;
 }
 
 VALUE
 pg_typemap_result_value( t_typemap *p_typemap, VALUE result, int tuple, int field )
 {
 	rb_raise( rb_eNotImpError, "type map is not suitable to map result values" );
-	return Qnil;
 }
 
 t_pg_coder *
 pg_typemap_typecast_query_param( t_typemap *p_typemap, VALUE param_value, int field )
 {
 	rb_raise( rb_eNotImpError, "type map is not suitable to map query params" );
-	return NULL;
 }
 
 VALUE
 pg_typemap_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, int format, int enc_idx )
 {
 	rb_raise( rb_eNotImpError, "type map is not suitable to map get_copy_data results" );
-	return Qnil;
 }
 
 const struct pg_typemap_funcs pg_typemap_funcs = {
-	.fit_to_result = pg_typemap_fit_to_result,
-	.fit_to_query = pg_typemap_fit_to_query,
-	.fit_to_copy_get = pg_typemap_fit_to_copy_get,
-	.typecast_result_value = pg_typemap_result_value,
-	.typecast_query_param = pg_typemap_typecast_query_param,
-	.typecast_copy_get = pg_typemap_typecast_copy_get
+	pg_typemap_fit_to_result,
+	pg_typemap_fit_to_query,
+	pg_typemap_fit_to_copy_get,
+	pg_typemap_result_value,
+	pg_typemap_typecast_query_param,
+	pg_typemap_typecast_copy_get
 };
 
 static VALUE

data/ext/pg_type_map_by_column.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map_by_column.c,v d369d31e8fe3 2014/10/22 08:47:29 lars $
+ * $Id: pg_type_map_by_column.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
  *
  */
 
@@ -162,12 +162,12 @@ pg_tmbc_typecast_copy_get( t_typemap *p_typemap, VALUE field_str, int fieldno, i
 }
 
 const struct pg_typemap_funcs pg_tmbc_funcs = {
-	.fit_to_result = pg_tmbc_fit_to_result,
-	.fit_to_query = pg_tmbc_fit_to_query,
-	.fit_to_copy_get = pg_tmbc_fit_to_copy_get,
-	.typecast_result_value = pg_tmbc_result_value,
-	.typecast_query_param = pg_tmbc_typecast_query_param,
-	.typecast_copy_get = pg_tmbc_typecast_copy_get
+	pg_tmbc_fit_to_result,
+	pg_tmbc_fit_to_query,
+	pg_tmbc_fit_to_copy_get,
+	pg_tmbc_result_value,
+	pg_tmbc_typecast_query_param,
+	pg_tmbc_typecast_copy_get
 };
 
 static void