pg 0.17.1 → 0.18.4

data/ext/util.c

@@ -0,0 +1,149 @@
+/*
+ * util.c - Utils for ruby-pg
+ * $Id: util.c,v 5fb9170f6a7d 2015/06/29 11:15:12 kanis $
+ *
+ */
+
+#include "pg.h"
+#include "util.h"
+
+static const char base64_encode_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* Encode _len_ bytes at _in_ as base64 and write output to _out_.
+ *
+ * This encoder runs backwards, so that it is possible to encode a string
+ * in-place (with _out_ == _in_).
+ */
+void
+base64_encode( char *out, char *in, int len)
+{
+	unsigned char *in_ptr = (unsigned char *)in + len;
+	char *out_ptr = out + BASE64_ENCODED_SIZE(len);
+	int part_len = len % 3;
+
+	if( part_len > 0 ){
+		long byte2 = part_len > 2 ? *--in_ptr : 0;
+		long byte1 = part_len > 1 ? *--in_ptr : 0;
+		long byte0 = *--in_ptr;
+		long triple = (byte0 << 16) + (byte1 << 8) + byte2;
+
+		*--out_ptr = part_len > 2 ? base64_encode_table[(triple >> 0 * 6) & 0x3F] : '=';
+		*--out_ptr = part_len > 1 ? base64_encode_table[(triple >> 1 * 6) & 0x3F] : '=';
+		*--out_ptr = base64_encode_table[(triple >> 2 * 6) & 0x3F];
+		*--out_ptr = base64_encode_table[(triple >> 3 * 6) & 0x3F];
+	}
+
+	while( out_ptr > out ){
+		long byte2 = *--in_ptr;
+		long byte1 = *--in_ptr;
+		long byte0 = *--in_ptr;
+		long triple = (byte0 << 16) + (byte1 << 8) + byte2;
+
+		*--out_ptr = base64_encode_table[(triple >> 0 * 6) & 0x3F];
+		*--out_ptr = base64_encode_table[(triple >> 1 * 6) & 0x3F];
+		*--out_ptr = base64_encode_table[(triple >> 2 * 6) & 0x3F];
+		*--out_ptr = base64_encode_table[(triple >> 3 * 6) & 0x3F];
+	}
+}
+
+/*
+ * 0.upto(255).map{|a| "\\x#{ (base64_encode_table.index([a].pack("C")) || 0xff).to_s(16) }" }.join
+ */
+static const unsigned char base64_decode_table[] =
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\xff\xff\xff\x3f"
+	"\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\xff\xff\xff\xff\xff\xff"
+	"\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e"
+	"\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xff\xff\xff\xff\xff"
+	"\xff\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28"
+	"\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
+	"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff";
+
+/* Decode _len_ bytes of base64 characters at _in_ and write output to _out_.
+ *
+ * It is possible to decode a string in-place (with _out_ == _in_).
+ */
+int
+base64_decode( char *out, char *in, unsigned int len)
+{
+	unsigned char a, b, c, d;
+	unsigned char *in_ptr = (unsigned char *)in;
+	unsigned char *out_ptr = (unsigned char *)out;
+	unsigned char *iend_ptr = (unsigned char *)in + len;
+
+	for(;;){
+		if( in_ptr+3 < iend_ptr &&
+				(a=base64_decode_table[in_ptr[0]]) != 0xff &&
+				(b=base64_decode_table[in_ptr[1]]) != 0xff &&
+				(c=base64_decode_table[in_ptr[2]]) != 0xff &&
+				(d=base64_decode_table[in_ptr[3]]) != 0xff )
+		{
+			in_ptr += 4;
+			*out_ptr++ = (a << 2) | (b >> 4);
+			*out_ptr++ = (b << 4) | (c >> 2);
+			*out_ptr++ = (c << 6) | d;
+		} else if (in_ptr < iend_ptr){
+			a = b = c = d = 0xff;
+			while ((a = base64_decode_table[*in_ptr++]) == 0xff && in_ptr < iend_ptr) {}
+			if (in_ptr < iend_ptr){
+				while ((b = base64_decode_table[*in_ptr++]) == 0xff && in_ptr < iend_ptr) {}
+				if (in_ptr < iend_ptr){
+					while ((c = base64_decode_table[*in_ptr++]) == 0xff && in_ptr < iend_ptr) {}
+					if (in_ptr < iend_ptr){
+						while ((d = base64_decode_table[*in_ptr++]) == 0xff && in_ptr < iend_ptr) {}
+					}
+				}
+			}
+			if (a != 0xff && b != 0xff) {
+				*out_ptr++ = (a << 2) | (b >> 4);
+				if (c != 0xff) {
+					*out_ptr++ = (b << 4) | (c >> 2);
+					if (d != 0xff)
+						*out_ptr++ = (c << 6) | d;
+				}
+			}
+		} else {
+			break;
+		}
+	}
+
+
+	return (char*)out_ptr - out;
+}
+
+/*
+ * Case-independent comparison of two not-necessarily-null-terminated strings.
+ * At most n bytes will be examined from each string.
+ */
+int
+rbpg_strncasecmp(const char *s1, const char *s2, size_t n)
+{
+	while (n-- > 0)
+	{
+		unsigned char ch1 = (unsigned char) *s1++;
+		unsigned char ch2 = (unsigned char) *s2++;
+
+		if (ch1 != ch2){
+			if (ch1 >= 'A' && ch1 <= 'Z')
+				ch1 += 'a' - 'A';
+
+			if (ch2 >= 'A' && ch2 <= 'Z')
+				ch2 += 'a' - 'A';
+
+			if (ch1 != ch2)
+				return (int) ch1 - (int) ch2;
+		}
+		if (ch1 == 0)
+			break;
+	}
+	return 0;
+}
+

data/ext/util.h

@@ -0,0 +1,65 @@
+/*
+ * utils.h
+ *
+ */
+
+#ifndef __utils_h
+#define __utils_h
+
+#define write_nbo16(l,c) ( \
+		*((unsigned char*)(c)+0)=(unsigned char)(((l)>>8)&0xff), \
+		*((unsigned char*)(c)+1)=(unsigned char)(((l)   )&0xff)\
+	)
+
+#define write_nbo32(l,c) ( \
+		*((unsigned char*)(c)+0)=(unsigned char)(((l)>>24L)&0xff), \
+		*((unsigned char*)(c)+1)=(unsigned char)(((l)>>16L)&0xff), \
+		*((unsigned char*)(c)+2)=(unsigned char)(((l)>> 8L)&0xff), \
+		*((unsigned char*)(c)+3)=(unsigned char)(((l)     )&0xff)\
+	)
+
+#define write_nbo64(l,c) ( \
+		*((unsigned char*)(c)+0)=(unsigned char)(((l)>>56LL)&0xff), \
+		*((unsigned char*)(c)+1)=(unsigned char)(((l)>>48LL)&0xff), \
+		*((unsigned char*)(c)+2)=(unsigned char)(((l)>>40LL)&0xff), \
+		*((unsigned char*)(c)+3)=(unsigned char)(((l)>>32LL)&0xff), \
+		*((unsigned char*)(c)+4)=(unsigned char)(((l)>>24LL)&0xff), \
+		*((unsigned char*)(c)+5)=(unsigned char)(((l)>>16LL)&0xff), \
+		*((unsigned char*)(c)+6)=(unsigned char)(((l)>> 8LL)&0xff), \
+		*((unsigned char*)(c)+7)=(unsigned char)(((l)      )&0xff)\
+	)
+
+#define read_nbo16(c) ((int16_t)( \
+		(((uint16_t)(*((unsigned char*)(c)+0)))<< 8L) | \
+		(((uint16_t)(*((unsigned char*)(c)+1)))     ) \
+	))
+
+#define read_nbo32(c) ((int32_t)( \
+		(((uint32_t)(*((unsigned char*)(c)+0)))<<24L) | \
+		(((uint32_t)(*((unsigned char*)(c)+1)))<<16L) | \
+		(((uint32_t)(*((unsigned char*)(c)+2)))<< 8L) | \
+		(((uint32_t)(*((unsigned char*)(c)+3)))     ) \
+	))
+
+#define read_nbo64(c) ((int64_t)( \
+		(((uint64_t)(*((unsigned char*)(c)+0)))<<56LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+1)))<<48LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+2)))<<40LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+3)))<<32LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+4)))<<24LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+5)))<<16LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+6)))<< 8LL) | \
+		(((uint64_t)(*((unsigned char*)(c)+7)))      ) \
+	))
+
+
+
+#define BASE64_ENCODED_SIZE(strlen) (((strlen) + 2) / 3 * 4)
+#define BASE64_DECODED_SIZE(base64len) (((base64len) + 3) / 4 * 3)
+
+void base64_encode( char *out, char *in, int len);
+int base64_decode( char *out, char *in, unsigned int len);
+
+int rbpg_strncasecmp(const char *s1, const char *s2, size_t n);
+
+#endif /* end __utils_h */

data/lib/pg/basic_type_mapping.rb

@@ -0,0 +1,399 @@
+#!/usr/bin/env ruby
+
+require 'pg' unless defined?( PG )
+
+module PG::BasicTypeRegistry
+	# An instance of this class stores the coders that should be used for a given wire format (text or binary)
+	# and type cast direction (encoder or decoder).
+	class CoderMap
+		# Hash of text types that don't require quotation, when used within composite types.
+		#   type.name => true
+		DONT_QUOTE_TYPES = %w[
+			int2 int4 int8
+			float4 float8
+			oid
+			bool
+			date timestamp timestamptz
+		].inject({}){|h,e| h[e] = true; h }
+
+		def initialize(result, coders_by_name, format, arraycoder)
+			coder_map = {}
+
+			_ranges, nodes = result.partition { |row| row['typinput'] == 'range_in' }
+			leaves, nodes = nodes.partition { |row| row['typelem'].to_i == 0 }
+			arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
+
+			# populate the enum types
+			_enums, leaves = leaves.partition { |row| row['typinput'] == 'enum_in' }
+			# enums.each do |row|
+			#	coder_map[row['oid'].to_i] = OID::Enum.new
+			# end
+
+			# populate the base types
+			leaves.find_all { |row| coders_by_name.key?(row['typname']) }.each do |row|
+				coder = coders_by_name[row['typname']].dup
+				coder.oid = row['oid'].to_i
+				coder.name = row['typname']
+				coder.format = format
+				coder_map[coder.oid] = coder
+			end
+
+			_records_by_oid = result.group_by { |row| row['oid'] }
+
+			# populate composite types
+			# nodes.each do |row|
+			#	add_oid row, records_by_oid, coder_map
+			# end
+
+			if arraycoder
+				# populate array types
+				arrays.each do |row|
+					elements_coder = coder_map[row['typelem'].to_i]
+					next unless elements_coder
+
+					coder = arraycoder.new
+					coder.oid = row['oid'].to_i
+					coder.name = row['typname']
+					coder.format = format
+					coder.elements_type = elements_coder
+					coder.needs_quotation = !DONT_QUOTE_TYPES[elements_coder.name]
+					coder_map[coder.oid] = coder
+				end
+			end
+
+			# populate range types
+			# ranges.find_all { |row| coder_map.key? row['rngsubtype'].to_i }.each do |row|
+			#	subcoder = coder_map[row['rngsubtype'].to_i]
+			#	range = OID::Range.new subcoder
+			#	coder_map[row['oid'].to_i] = range
+			# end
+
+			@coders = coder_map.values
+			@coders_by_name = @coders.inject({}){|h, t| h[t.name] = t; h }
+			@coders_by_oid = @coders.inject({}){|h, t| h[t.oid] = t; h }
+			@typenames_by_oid = result.inject({}){|h, t| h[t['oid'].to_i] = t['typname']; h }
+		end
+
+		attr_reader :coders
+		attr_reader :coders_by_oid
+		attr_reader :coders_by_name
+		attr_reader :typenames_by_oid
+
+		def coder_by_name(name)
+			@coders_by_name[name]
+		end
+
+		def coder_by_oid(oid)
+			@coders_by_oid[oid]
+		end
+	end
+
+	private
+
+	def supports_ranges?(connection)
+		connection.server_version >= 90200
+	end
+
+	def build_coder_maps(connection)
+		if supports_ranges?(connection)
+			result = connection.exec <<-SQL
+				SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype
+				FROM pg_type as t
+				LEFT JOIN pg_range as r ON oid = rngtypid
+			SQL
+		else
+			result = connection.exec <<-SQL
+				SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput
+				FROM pg_type as t
+			SQL
+		end
+
+		[
+			[0, :encoder, PG::TextEncoder::Array],
+			[0, :decoder, PG::TextDecoder::Array],
+			[1, :encoder, nil],
+			[1, :decoder, nil],
+		].inject([]) do |h, (format, direction, arraycoder)|
+			h[format] ||= {}
+			h[format][direction] = CoderMap.new result, CODERS_BY_NAME[format][direction], format, arraycoder
+			h
+		end
+	end
+
+	ValidFormats = { 0 => true, 1 => true }
+	ValidDirections = { :encoder => true, :decoder => true }
+
+	def check_format_and_direction(format, direction)
+		raise(ArgumentError, "Invalid format value %p" % format) unless ValidFormats[format]
+		raise(ArgumentError, "Invalid direction %p" % direction) unless ValidDirections[direction]
+	end
+	protected :check_format_and_direction
+
+	# The key of this hash maps to the `typname` column from the table.
+	# encoder_map is then dynamically built with oids as the key and Type
+	# objects as values.
+	CODERS_BY_NAME = []
+
+	# Register an OID type named +name+ with a typecasting encoder and decoder object in
+	# +type+.  +name+ should correspond to the `typname` column in
+	# the `pg_type` table.
+	def self.register_type(format, name, encoder_class, decoder_class)
+		CODERS_BY_NAME[format] ||= { encoder: {}, decoder: {} }
+		CODERS_BY_NAME[format][:encoder][name] = encoder_class.new(name: name, format: format) if encoder_class
+		CODERS_BY_NAME[format][:decoder][name] = decoder_class.new(name: name, format: format) if decoder_class
+	end
+
+	# Alias the +old+ type to the +new+ type.
+	def self.alias_type(format, new, old)
+		CODERS_BY_NAME[format][:encoder][new] = CODERS_BY_NAME[format][:encoder][old]
+		CODERS_BY_NAME[format][:decoder][new] = CODERS_BY_NAME[format][:decoder][old]
+	end
+
+	register_type 0, 'int2', PG::TextEncoder::Integer, PG::TextDecoder::Integer
+	alias_type    0, 'int4', 'int2'
+	alias_type    0, 'int8', 'int2'
+	alias_type    0, 'oid',  'int2'
+
+	# register_type 0, 'numeric', OID::Decimal.new
+	register_type 0, 'text', PG::TextEncoder::String, PG::TextDecoder::String
+	alias_type 0, 'varchar', 'text'
+	alias_type 0, 'char', 'text'
+	alias_type 0, 'bpchar', 'text'
+	alias_type 0, 'xml', 'text'
+
+	# FIXME: why are we keeping these types as strings?
+	# alias_type 'tsvector', 'text'
+	# alias_type 'interval', 'text'
+	# alias_type 'macaddr',  'text'
+	# alias_type 'uuid',     'text'
+	#
+	# register_type 'money', OID::Money.new
+	# There is no PG::TextEncoder::Bytea, because it's simple and more efficient to send bytea-data
+	# in binary format, either with PG::BinaryEncoder::Bytea or in Hash param format.
+	register_type 0, 'bytea', nil, PG::TextDecoder::Bytea
+	register_type 0, 'bool', PG::TextEncoder::Boolean, PG::TextDecoder::Boolean
+	# register_type 'bit', OID::Bit.new
+	# register_type 'varbit', OID::Bit.new
+
+	register_type 0, 'float4', PG::TextEncoder::Float, PG::TextDecoder::Float
+	alias_type 0, 'float8', 'float4'
+
+	register_type 0, 'timestamp', PG::TextEncoder::TimestampWithoutTimeZone, PG::TextDecoder::TimestampWithoutTimeZone
+	register_type 0, 'timestamptz', PG::TextEncoder::TimestampWithTimeZone, PG::TextDecoder::TimestampWithTimeZone
+	register_type 0, 'date', PG::TextEncoder::Date, PG::TextDecoder::Date
+	# register_type 'time', OID::Time.new
+	#
+	# register_type 'path', OID::Text.new
+	# register_type 'point', OID::Point.new
+	# 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 'citext', OID::Text.new
+	# register_type 'ltree', OID::Text.new
+	#
+	# register_type 'cidr', OID::Cidr.new
+	# alias_type 'inet', 'cidr'
+
+
+
+	register_type 1, 'int2', PG::BinaryEncoder::Int2, PG::BinaryDecoder::Integer
+	register_type 1, 'int4', PG::BinaryEncoder::Int4, PG::BinaryDecoder::Integer
+	register_type 1, 'int8', PG::BinaryEncoder::Int8, PG::BinaryDecoder::Integer
+	alias_type    1, 'oid',  'int2'
+
+	register_type 1, 'text', PG::BinaryEncoder::String, PG::BinaryDecoder::String
+	alias_type 1, 'varchar', 'text'
+	alias_type 1, 'char', 'text'
+	alias_type 1, 'bpchar', 'text'
+	alias_type 1, 'xml', 'text'
+
+	register_type 1, 'bytea', PG::BinaryEncoder::Bytea, PG::BinaryDecoder::Bytea
+	register_type 1, 'bool', PG::BinaryEncoder::Boolean, PG::BinaryDecoder::Boolean
+	register_type 1, 'float4', nil, PG::BinaryDecoder::Float
+	register_type 1, 'float8', nil, PG::BinaryDecoder::Float
+end
+
+# Simple set of rules for type casting common PostgreSQL types to Ruby.
+#
+# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
+# PostgreSQL's pg_type table in PG::BasicTypeMapForResults.new .
+#
+# Result values are type casted based on the type OID of the given result column.
+#
+# 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.
+#
+# Example:
+#   conn = PG::Connection.new
+#   # Assign a default ruleset for type casts of input and output values.
+#   conn.type_mapping = PG::BasicTypeMapping.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
+#   # is done by PG::TextDecoder::Integer internally for all value retrieval methods.
+#   res.values  # => [[5]]
+#
+# 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 .
+#
+class PG::BasicTypeMapForResults < PG::TypeMapByOid
+	include PG::BasicTypeRegistry
+
+	class WarningTypeMap < PG::TypeMapInRuby
+		def initialize(typenames)
+			@already_warned = Hash.new{|h, k| h[k] = {} }
+			@typenames_by_oid = typenames
+		end
+
+		def typecast_result_value(result, _tuple, field)
+			format = result.fformat(field)
+			oid = result.ftype(field)
+			unless @already_warned[format][oid]
+				STDERR.puts "Warning: no type cast defined for type #{@typenames_by_oid[format][oid].inspect} with oid #{oid}. Please cast this type explicitly to TEXT to be safe for future changes."
+				 @already_warned[format][oid] = true
+			end
+			super
+		end
+	end
+
+	def initialize(connection)
+		@coder_maps = build_coder_maps(connection)
+
+		# Populate TypeMapByOid hash with decoders
+		@coder_maps.map{|f| f[:decoder].coders }.flatten.each do |coder|
+			add_coder(coder)
+		end
+
+		typenames = @coder_maps.map{|f| f[:decoder].typenames_by_oid }
+		self.default_type_map = WarningTypeMap.new(typenames)
+	end
+end
+
+# Simple set of rules for type casting common PostgreSQL types from Ruby
+# to PostgreSQL.
+#
+# OIDs of supported type casts are not hard-coded in the sources, but are retrieved from the
+# PostgreSQL's pg_type table in PG::BasicTypeMapBasedOnResult.new .
+#
+# This class works equal to PG::BasicTypeMapForResults, but does not define decoders for
+# the given result OIDs, but encoders. So it can be used to type cast field values based on
+# the type OID retrieved by a separate SQL query.
+#
+# PG::TypeMapByOid#build_column_map(result) can be used to generate a result independent
+# PG::TypeMapByColumn type map, which can subsequently be used to cast query bind parameters
+# or #put_copy_data fields.
+#
+# Example:
+#   conn.exec( "CREATE TEMP TABLE copytable (t TEXT, i INT, ai INT[])" )
+#
+#   # Retrieve table OIDs per empty result set.
+#   res = conn.exec( "SELECT * FROM copytable LIMIT 0" )
+#   tm = basic_type_mapping.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
+class PG::BasicTypeMapBasedOnResult < PG::TypeMapByOid
+	include PG::BasicTypeRegistry
+
+	def initialize(connection)
+		@coder_maps = build_coder_maps(connection)
+
+		# Populate TypeMapByOid hash with encoders
+		@coder_maps.map{|f| f[:encoder].coders }.flatten.each do |coder|
+			add_coder(coder)
+		end
+	end
+end
+
+# Simple set of rules for type casting common Ruby types to PostgreSQL.
+#
+# 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.
+#
+# 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.
+#
+# 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)
+#   # 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] )
+class PG::BasicTypeMapForQueries < PG::TypeMapByClass
+	include PG::BasicTypeRegistry
+
+	def initialize(connection)
+		@coder_maps = build_coder_maps(connection)
+
+		populate_encoder_list
+		@array_encoders_by_klass = array_encoders_by_klass
+		@anyarray_encoder = coder_by_name(0, :encoder, '_any')
+	end
+
+	private
+
+	def coder_by_name(format, direction, name)
+		check_format_and_direction(format, direction)
+		@coder_maps[format][direction].coder_by_name(name)
+	end
+
+	def populate_encoder_list
+		DEFAULT_TYPE_MAP.each do |klass, selector|
+			if Array === selector
+				format, name, oid_name = selector
+				coder = coder_by_name(format, :encoder, name).dup
+				if oid_name
+					coder.oid = coder_by_name(format, :encoder, oid_name).oid
+				else
+					coder.oid = 0
+				end
+				self[klass] = coder
+			else
+				self[klass] = selector
+			end
+		end
+	end
+
+	def array_encoders_by_klass
+		DEFAULT_ARRAY_TYPE_MAP.inject({}) do |h, (klass, (format, name))|
+			h[klass] = coder_by_name(format, :encoder, name)
+			h
+		end
+	end
+
+	def get_array_type(value)
+		elem = value
+		while elem.kind_of?(Array)
+			elem = elem.first
+		end
+		@array_encoders_by_klass[elem.class] ||
+				elem.class.ancestors.lazy.map{|ancestor| @array_encoders_by_klass[ancestor] }.find{|a| a } ||
+				@anyarray_encoder
+	end
+
+	DEFAULT_TYPE_MAP = {
+		TrueClass => [1, 'bool', 'bool'],
+		FalseClass => [1, 'bool', 'bool'],
+		# We use text format and no type OID for numbers, because setting the OID can lead
+		# to unnecessary type conversions on server side.
+		Integer => [0, 'int8'],
+		Float => [0, 'float8'],
+		Array => :get_array_type,
+	}
+
+	DEFAULT_ARRAY_TYPE_MAP = {
+		TrueClass => [0, '_bool'],
+		FalseClass => [0, '_bool'],
+		Integer => [0, '_int8'],
+		String => [0, '_text'],
+		Float => [0, '_float8'],
+	}
+
+end

data/lib/pg/coder.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+
+module PG
+
+	class Coder
+
+		module BinaryFormatting
+			Params = { format: 1 }
+			def initialize( params={} )
+				super(params.merge(Params))
+			end
+		end
+
+
+		# Create a new coder object based on the attribute Hash.
+		def initialize(params={})
+			params.each do |key, val|
+				send("#{key}=", val)
+			end
+		end
+
+		def dup
+			self.class.new(to_h)
+		end
+
+		# Returns coder attributes as Hash.
+		def to_h
+			{
+				oid: oid,
+				format: format,
+				name: name,
+			}
+		end
+
+		def ==(v)
+			self.class == v.class && to_h == v.to_h
+		end
+
+		def marshal_dump
+			Marshal.dump(to_h)
+		end
+
+		def marshal_load(str)
+			initialize Marshal.load(str)
+		end
+
+		def inspect
+			str = self.to_s
+			oid_str = " oid=#{oid}" unless oid==0
+			format_str = " format=#{format}" unless format==0
+			name_str = " #{name.inspect}" if name
+			str[-1,0] = "#{name_str} #{oid_str}#{format_str}"
+			str
+		end
+	end
+
+	class CompositeCoder < Coder
+		def to_h
+			super.merge!({
+				elements_type: elements_type,
+				needs_quotation: needs_quotation?,
+				delimiter: delimiter,
+			})
+		end
+
+		def inspect
+			str = super
+			str[-1,0] = " elements_type=#{elements_type.inspect} #{needs_quotation? ? 'needs' : 'no'} quotation"
+			str
+		end
+	end
+
+	class CopyCoder < Coder
+		def to_h
+			super.merge!({
+				type_map: type_map,
+				delimiter: delimiter,
+				null_string: null_string,
+			})
+		end
+	end
+end # module PG
+