pg 0.18.4 → 0.21.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 c4a1abc36c47 2017/06/02 01:00:09 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'
@@ -302,7 +302,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 +414,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 +466,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 +527,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 +552,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 +696,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 +721,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 +772,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

data/ext/pg_text_encoder.c

@@ -1,6 +1,6 @@
 /*
  * pg_text_encoder.c - PG::TextEncoder module
- * $Id: pg_text_encoder.c,v 4f0bd19e9111 2015/09/24 18:55:11 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.
@@ -50,7 +51,7 @@ 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 )
@@ -76,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:
@@ -94,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;
@@ -113,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;
 }
 
@@ -129,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;
@@ -206,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);
 		}
 	}
 }
@@ -225,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);
@@ -265,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);
@@ -344,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 */
@@ -376,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;
 
@@ -407,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 );
@@ -417,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 );
@@ -439,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 );
 	}
 }
 
@@ -484,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;
@@ -496,6 +504,9 @@ pg_text_enc_array_identifier(VALUE value, VALUE string, char *out)
 		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 );
@@ -517,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;
 }
 
@@ -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;

data/ext/pg_type_map.c

@@ -1,6 +1,6 @@
 /*
  * pg_column_map.c - PG::ColumnMap class extension
- * $Id: pg_type_map.c,v fcf731d3dff7 2015/09/08 12:25:06 jfali $
+ * $Id: pg_type_map.c,v 2af122820861 2017/01/14 19:56:36 lars $
  *
  */
 
@@ -11,46 +11,53 @@ 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 = {

data/lib/pg/basic_type_mapping.rb

@@ -188,7 +188,8 @@ module PG::BasicTypeRegistry
 	# register_type 'polygon', OID::Text.new
 	# register_type 'circle', OID::Text.new
 	# register_type 'hstore', OID::Hstore.new
-	# register_type 'json', OID::Json.new
+	register_type 0, 'json', PG::TextEncoder::JSON, PG::TextDecoder::JSON
+	alias_type    0, 'jsonb',  'json'
 	# register_type 'citext', OID::Text.new
 	# register_type 'ltree', OID::Text.new
 	#
@@ -226,8 +227,8 @@ end
 #
 # Example:
 #   conn = PG::Connection.new
-#   # Assign a default ruleset for type casts of input and output values.
-#   conn.type_mapping = PG::BasicTypeMapping.new(conn)
+#   # Assign a default ruleset for type casts of output values.
+#   conn.type_map_for_results = PG::BasicTypeMapForResults.new(conn)
 #   # Execute a query.
 #   res = conn.exec_params( "SELECT $1::INT", ['5'] )
 #   # Retrieve and cast the result value. Value format is 0 (text) and OID is 20. Therefore typecasting
@@ -236,8 +237,28 @@ end
 #
 # PG::TypeMapByOid#fit_to_result(result, false) can be used to generate
 # a result independent PG::TypeMapByColumn type map, which can subsequently be used
-# to cast #get_copy_data fields. See also PG::BasicTypeMapBasedOnResult .
+# to cast #get_copy_data fields:
+#
+# For the following table:
+#   conn.exec( "CREATE TABLE copytable AS VALUES('a', 123, '{5,4,3}'::INT[])" )
+#
+#   # Retrieve table OIDs per empty result set.
+#   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
+#   # Build a type map for common database to ruby type decoders.
+#   btm = PG::BasicTypeMapForResults.new(conn)
+#   # Build a PG::TypeMapByColumn with decoders suitable for copytable.
+#   tm = btm.build_column_map( res )
+#   row_decoder = PG::TextDecoder::CopyRow.new type_map: tm
+#
+#   conn.copy_data( "COPY copytable TO STDOUT", row_decoder ) do |res|
+#     while row=conn.get_copy_data
+#       p row
+#     end
+#   end
+# This prints the rows with type casted columns:
+#   ["a", 123, [5, 4, 3]]
 #
+# See also PG::BasicTypeMapBasedOnResult for the encoder direction.
 class PG::BasicTypeMapForResults < PG::TypeMapByOid
 	include PG::BasicTypeRegistry
 
@@ -290,12 +311,17 @@ end
 #
 #   # Retrieve table OIDs per empty result set.
 #   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
-#   tm = basic_type_mapping.build_column_map( res )
+#   # Build a type map for common ruby to database type encoders.
+#   btm = PG::BasicTypeMapBasedOnResult.new(conn)
+#   # Build a PG::TypeMapByColumn with encoders suitable for copytable.
+#   tm = btm.build_column_map( res )
 #   row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
 #
 #   conn.copy_data( "COPY copytable FROM STDIN", row_encoder ) do |res|
 #     conn.put_copy_data ['a', 123, [5,4,3]]
 #   end
+# This inserts a single row into copytable with type casts from ruby to
+# database types.
 class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
 	include PG::BasicTypeRegistry
 
@@ -314,15 +340,16 @@ end
 # OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
 # PostgreSQL's pg_type table in PG::BasicTypeMapForQueries.new .
 #
-# Query params are type casted based on the MRI internal type of the given value.
+# Query params are type casted based on the class of the given value.
 #
 # Higher level libraries will most likely not make use of this class, but use their
-# own set of rules to choose suitable encoders and decoders.
+# own derivation of PG::TypeMapByClass or another set of rules to choose suitable
+# encoders and decoders for the values to be sent.
 #
 # Example:
 #   conn = PG::Connection.new
 #   # Assign a default ruleset for type casts of input and output values.
-#   conn.type_mapping_for_queries = PG::BasicTypeMapForQueries.new(conn)
+#   conn.type_map_for_queries = PG::BasicTypeMapForQueries.new(conn)
 #   # Execute a query. The Integer param value is typecasted internally by PG::BinaryEncoder::Int8.
 #   # The format of the parameter is set to 1 (binary) and the OID of this parameter is set to 20 (int8).
 #   res = conn.exec_params( "SELECT $1", [5] )