pg 1.0.0 → 1.5.9

data/spec/pg/type_map_by_column_spec.rb

@@ -1,222 +0,0 @@
-#!/usr/bin/env rspec
-# encoding: utf-8
-
-require_relative '../helpers'
-
-require 'pg'
-
-
-describe PG::TypeMapByColumn do
-
-	let!(:textenc_int){ PG::TextEncoder::Integer.new name: 'INT4', oid: 23 }
-	let!(:textdec_int){ PG::TextDecoder::Integer.new name: 'INT4', oid: 23 }
-	let!(:textenc_float){ PG::TextEncoder::Float.new name: 'FLOAT4', oid: 700 }
-	let!(:textdec_float){ PG::TextDecoder::Float.new name: 'FLOAT4', oid: 700 }
-	let!(:textenc_string){ PG::TextEncoder::String.new name: 'TEXT', oid: 25 }
-	let!(:textdec_string){ PG::TextDecoder::String.new name: 'TEXT', oid: 25 }
-	let!(:textdec_bytea){ PG::TextDecoder::Bytea.new name: 'BYTEA', oid: 17 }
-	let!(:binaryenc_bytea){ PG::BinaryEncoder::Bytea.new name: 'BYTEA', oid: 17, format: 1 }
-	let!(:binarydec_bytea){ PG::BinaryDecoder::Bytea.new name: 'BYTEA', oid: 17, format: 1 }
-	let!(:pass_through_type) do
-		type = Class.new(PG::SimpleDecoder) do
-			def decode(*v)
-				v
-			end
-		end.new
-		type.oid = 123456
-		type.format = 1
-		type.name = 'pass_through'
-		type
-	end
-
-	it "should retrieve it's conversions" do
-		cm = PG::TypeMapByColumn.new( [textdec_int, textenc_string, textdec_float, pass_through_type, nil] )
-		expect( cm.coders ).to eq( [
-			textdec_int,
-			textenc_string,
-			textdec_float,
-			pass_through_type,
-			nil
-		] )
-		expect( cm.inspect ).to eq( "#<PG::TypeMapByColumn INT4:0 TEXT:0 FLOAT4:0 pass_through:1 nil>" )
-	end
-
-	it "should retrieve it's oids" do
-		cm = PG::TypeMapByColumn.new( [textdec_int, textdec_string, textdec_float, pass_through_type, nil] )
-		expect( cm.oids ).to eq( [23, 25, 700, 123456, nil] )
-	end
-
-	it "should gracefully handle not initialized state" do
-		# PG::TypeMapByColumn is not initialized in allocate function, like other
-		# type maps, but in #initialize. So it might be not called by derived classes.
-
-		not_init = Class.new(PG::TypeMapByColumn) do
-			def initialize
-				# no super call
-			end
-		end.new
-
-		expect{ @conn.exec_params( "SELECT $1", [ 0 ], 0, not_init ) }.to raise_error(NotImplementedError)
-
-		res = @conn.exec( "SELECT 1" )
-		expect{ res.type_map = not_init }.to raise_error(NotImplementedError)
-
-		@conn.copy_data("COPY (SELECT 1) TO STDOUT") do
-			decoder = PG::TextDecoder::CopyRow.new(type_map: not_init)
-			expect{ @conn.get_copy_data(false, decoder) }.to raise_error(NotImplementedError)
-			@conn.get_copy_data
-		end
-	end
-
-
-	#
-	# Encoding Examples
-	#
-
-	it "should encode integer params" do
-		col_map = PG::TypeMapByColumn.new( [textenc_int]*3 )
-		res = @conn.exec_params( "SELECT $1, $2, $3", [ 0, nil, "-999" ], 0, col_map )
-		expect( res.values ).to eq( [
-				[ "0", nil, "-999" ],
-		] )
-	end
-
-	it "should encode bytea params" do
-		data = "'\u001F\\"
-		col_map = PG::TypeMapByColumn.new( [binaryenc_bytea]*2 )
-		res = @conn.exec_params( "SELECT $1, $2", [ data, nil ], 0, col_map )
-		res.type_map = PG::TypeMapByColumn.new( [textdec_bytea]*2 )
-		expect( res.values ).to eq( [
-				[ data, nil ],
-		] )
-	end
-
-
-	it "should allow hash form parameters for default encoder" do
-		col_map = PG::TypeMapByColumn.new( [nil, nil] )
-		hash_param_bin = { value: ["00ff"].pack("H*"), type: 17, format: 1 }
-		hash_param_nil = { value: nil, type: 17, format: 1 }
-		res = @conn.exec_params( "SELECT $1, $2",
-					[ hash_param_bin, hash_param_nil ], 0, col_map )
-		expect( res.values ).to eq( [["\\x00ff", nil]] )
-		expect( result_typenames(res) ).to eq( ['bytea', 'bytea'] )
-	end
-
-	it "should convert hash form parameters to string when using string encoders" do
-		col_map = PG::TypeMapByColumn.new( [textenc_string, textenc_string] )
-		hash_param_bin = { value: ["00ff"].pack("H*"), type: 17, format: 1 }
-		hash_param_nil = { value: nil, type: 17, format: 1 }
-		res = @conn.exec_params( "SELECT $1::text, $2::text",
-					[ hash_param_bin, hash_param_nil ], 0, col_map )
-		expect( res.values ).to eq( [["{:value=>\"\\x00\\xFF\", :type=>17, :format=>1}", "{:value=>nil, :type=>17, :format=>1}"]] )
-	end
-
-	it "shouldn't allow param mappings with different number of fields" do
-		expect{
-			@conn.exec_params( "SELECT $1", [ 123 ], 0, PG::TypeMapByColumn.new([]) )
-		}.to raise_error(ArgumentError, /mapped columns/)
-	end
-
-	it "should verify the default type map for query params as well" do
-		tm1 = PG::TypeMapByColumn.new([])
-		expect{
-			@conn.exec_params( "SELECT $1", [ 123 ], 0, PG::TypeMapByColumn.new([nil]).with_default_type_map(tm1) )
-		}.to raise_error(ArgumentError, /mapped columns/)
-	end
-
-	it "forwards query param conversions to the #default_type_map" do
-		tm1 = PG::TypeMapByClass.new
-		tm1[Integer] = PG::TextEncoder::Integer.new name: 'INT2', oid: 21
-
-		tm2 = PG::TypeMapByColumn.new( [textenc_int, nil, nil] ).with_default_type_map( tm1 )
-		res = @conn.exec_params( "SELECT $1, $2, $3::TEXT", [1, 2, :abc], 0, tm2 )
-
-		expect( res.ftype(0) ).to eq( 23 ) # tm2
-		expect( res.ftype(1) ).to eq( 21 ) # tm1
-		expect( res.getvalue(0,2) ).to eq( "abc" ) # TypeMapAllStrings
-	end
-
-	#
-	# Decoding Examples
-	#
-
-	class Exception_in_decode < PG::SimpleDecoder
-		def decode(res, tuple, field)
-			raise "no type decoder defined for tuple #{tuple} field #{field}"
-		end
-	end
-
-	it "should raise an error from decode method of type converter" do
-		res = @conn.exec( "SELECT now()" )
-		types = Array.new( res.nfields, Exception_in_decode.new )
-		res.type_map = PG::TypeMapByColumn.new( types )
-		expect{ res.values }.to raise_error(/no type decoder defined/)
-	end
-
-	it "should raise an error for invalid params" do
-		expect{ PG::TypeMapByColumn.new( :WrongType ) }.to raise_error(TypeError, /wrong argument type/)
-		expect{ PG::TypeMapByColumn.new( [123] ) }.to raise_error(ArgumentError, /invalid/)
-	end
-
-	it "shouldn't allow result mappings with different number of fields" do
-		res = @conn.exec( "SELECT 1" )
-		expect{ res.type_map = PG::TypeMapByColumn.new([]) }.to raise_error(ArgumentError, /mapped columns/)
-	end
-
-	it "should verify the default type map for result values as well" do
-		res = @conn.exec( "SELECT 1" )
-		tm1 = PG::TypeMapByColumn.new([])
-		expect{
-			res.type_map = PG::TypeMapByColumn.new([nil]).with_default_type_map(tm1)
-		}.to raise_error(ArgumentError, /mapped columns/)
-	end
-
-	it "forwards result value conversions to a TypeMapByOid as #default_type_map" do
-		# One run with implicit built TypeMapByColumn and another with online lookup
-		[0, 10].each do |max_rows|
-			tm1 = PG::TypeMapByOid.new
-			tm1.add_coder PG::TextDecoder::Integer.new name: 'INT2', oid: 21
-			tm1.max_rows_for_online_lookup = max_rows
-
-			tm2 = PG::TypeMapByColumn.new( [textdec_int, nil, nil] ).with_default_type_map( tm1 )
-			res = @conn.exec( "SELECT '1'::INT4, '2'::INT2, '3'::INT8" ).map_types!( tm2 )
-
-			expect( res.getvalue(0,0) ).to eq( 1 ) # tm2
-			expect( res.getvalue(0,1) ).to eq( 2 ) # tm1
-			expect( res.getvalue(0,2) ).to eq( "3" ) # TypeMapAllStrings
-		end
-	end
-
-	it "forwards get_copy_data conversions to another TypeMapByColumn as #default_type_map" do
-		tm1 = PG::TypeMapByColumn.new( [textdec_int, nil, nil] )
-		tm2 = PG::TypeMapByColumn.new( [nil, textdec_int, nil] ).with_default_type_map( tm1 )
-		decoder = PG::TextDecoder::CopyRow.new(type_map: tm2)
-		@conn.copy_data("COPY (SELECT 1, 2, 3) TO STDOUT", decoder) do
-			expect( @conn.get_copy_data ).to eq( [1, 2, '3'] )
-			@conn.get_copy_data
-		end
-	end
-
-	it "will deny copy queries with different column count" do
-		[[2, 2], [2, 3], [3, 2]].each do |cols1, cols2|
-			tm1 = PG::TypeMapByColumn.new( [textdec_int, nil, nil][0, cols1] )
-			tm2 = PG::TypeMapByColumn.new( [nil, textdec_int, nil][0, cols2] ).with_default_type_map( tm1 )
-			decoder = PG::TextDecoder::CopyRow.new(type_map: tm2)
-			@conn.copy_data("COPY (SELECT 1, 2, 3) TO STDOUT", decoder) do
-				expect{ @conn.get_copy_data }.to raise_error(ArgumentError, /number of copy fields/)
-				@conn.get_copy_data
-			end
-		end
-	end
-
-	#
-	# Decoding Examples text format
-	#
-
-	it "should allow mixed type conversions" do
-		res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, '2013-06-30'::DATE, 3" )
-		res.type_map = PG::TypeMapByColumn.new( [textdec_int, textdec_string, textdec_float, pass_through_type, nil] )
-		expect( res.values ).to eq( [[1, 'a', 2.0, ['2013-06-30', 0, 3], '3' ]] )
-	end
-
-end

data/spec/pg/type_map_by_mri_type_spec.rb

@@ -1,136 +0,0 @@
-#!/usr/bin/env rspec
-# encoding: utf-8
-
-require_relative '../helpers'
-
-require 'pg'
-
-
-describe PG::TypeMapByMriType do
-
-	let!(:textenc_int){ PG::TextEncoder::Integer.new name: 'INT4', oid: 23 }
-	let!(:textenc_float){ PG::TextEncoder::Float.new name: 'FLOAT8', oid: 701 }
-	let!(:textenc_string){ PG::TextEncoder::String.new name: 'TEXT', oid: 25 }
-	let!(:binaryenc_int){ PG::BinaryEncoder::Int8.new name: 'INT8', oid: 20, format: 1 }
-	let!(:pass_through_type) do
-		type = Class.new(PG::SimpleEncoder) do
-			def encode(*v)
-				v.inspect
-			end
-		end.new
-		type.oid = 25
-		type.format = 0
-		type.name = 'pass_through'
-		type
-	end
-
-	let!(:tm) do
-		tm = PG::TypeMapByMriType.new
-		tm['T_FIXNUM'] = binaryenc_int
-		tm['T_FLOAT'] = textenc_float
-		tm['T_SYMBOL'] = pass_through_type
-		tm
-	end
-
-	let!(:derived_tm) do
-		tm = Class.new(PG::TypeMapByMriType) do
-			def array_type_map_for(value)
-				PG::TextEncoder::Array.new name: '_INT4', oid: 1007, elements_type: PG::TextEncoder::Integer.new
-			end
-		end.new
-		tm['T_FIXNUM'] = proc{|value| textenc_int }
-		tm['T_REGEXP'] = proc{|value| :invalid }
-		tm['T_ARRAY'] = :array_type_map_for
-		tm
-	end
-
-	it "should retrieve all conversions" do
-		expect( tm.coders ).to eq( {
-			"T_FIXNUM" => binaryenc_int,
-			"T_FLOAT" => textenc_float,
-			"T_SYMBOL" => pass_through_type,
-			"T_HASH" => nil,
-			"T_ARRAY" => nil,
-			"T_BIGNUM" => nil,
-			"T_CLASS" => nil,
-			"T_COMPLEX" => nil,
-			"T_DATA" => nil,
-			"T_FALSE" => nil,
-			"T_FILE" => nil,
-			"T_MODULE" => nil,
-			"T_OBJECT" => nil,
-			"T_RATIONAL" => nil,
-			"T_REGEXP" => nil,
-			"T_STRING" => nil,
-			"T_STRUCT" => nil,
-			"T_TRUE" => nil,
-		} )
-	end
-
-	it "should retrieve particular conversions" do
-		expect( tm['T_FIXNUM'] ).to eq(binaryenc_int)
-		expect( tm['T_FLOAT'] ).to eq(textenc_float)
-		expect( tm['T_BIGNUM'] ).to be_nil
-		expect( derived_tm['T_REGEXP'] ).to be_kind_of(Proc)
-		expect( derived_tm['T_ARRAY'] ).to eq(:array_type_map_for)
-	end
-
-	it "should allow deletion of coders" do
-		tm['T_FIXNUM'] = nil
-		expect( tm['T_FIXNUM'] ).to be_nil
-	end
-
-	it "should check MRI type key" do
-		expect{ tm['NO_TYPE'] }.to raise_error(ArgumentError)
-		expect{ tm[123] }.to raise_error(TypeError)
-		expect{ tm['NO_TYPE'] = textenc_float }.to raise_error(ArgumentError)
-		expect{ tm[123] = textenc_float }.to raise_error(TypeError)
-	end
-
-	it "forwards query param conversions to the #default_type_map" do
-		tm1 = PG::TypeMapByColumn.new( [textenc_int, nil, nil] )
-
-		tm2 = PG::TypeMapByMriType.new
-		tm2['T_FIXNUM'] = PG::TextEncoder::Integer.new name: 'INT2', oid: 21
-		tm2.default_type_map = tm1
-
-		res = @conn.exec_params( "SELECT $1, $2, $3::TEXT", ['1', 2, 3], 0, tm2 )
-
-		expect( res.ftype(0) ).to eq( 23 ) # tm1
-		expect( res.ftype(1) ).to eq( 21 ) # tm2
-		expect( res.getvalue(0,2) ).to eq( "3" ) # TypeMapAllStrings
-	end
-
-	#
-	# Decoding Examples
-	#
-
-	it "should raise an error when used for results" do
-		res = @conn.exec_params( "SELECT 1", [], 1 )
-		expect{ res.type_map = tm }.to raise_error(NotImplementedError, /not suitable to map result values/)
-	end
-
-	#
-	# Encoding Examples
-	#
-
-	it "should allow mixed type conversions" do
-		res = @conn.exec_params( "SELECT $1, $2, $3", [5, 1.23, :TestSymbol], 0, tm )
-		expect( res.values ).to eq([['5', '1.23', "[:TestSymbol, #{@conn.internal_encoding.inspect}]"]])
-		expect( res.ftype(0) ).to eq(20)
-	end
-
-	it "should allow mixed type conversions with derived type map" do
-		res = @conn.exec_params( "SELECT $1, $2", [6, [7]], 0, derived_tm )
-		expect( res.values ).to eq([['6', '{7}']])
-		expect( res.ftype(0) ).to eq(23)
-		expect( res.ftype(1) ).to eq(1007)
-	end
-
-	it "should raise TypeError with derived type map" do
-		expect{
-			@conn.exec_params( "SELECT $1", [//], 0, derived_tm )
-		}.to raise_error(TypeError, /argument 1/)
-	end
-
-end

data/spec/pg/type_map_by_oid_spec.rb

@@ -1,149 +0,0 @@
-#!/usr/bin/env rspec
-# encoding: utf-8
-
-require_relative '../helpers'
-
-require 'pg'
-
-
-describe PG::TypeMapByOid do
-
-	let!(:textdec_int){ PG::TextDecoder::Integer.new name: 'INT4', oid: 23 }
-	let!(:textdec_float){ PG::TextDecoder::Float.new name: 'FLOAT8', oid: 701 }
-	let!(:textdec_string){ PG::TextDecoder::String.new name: 'TEXT', oid: 25 }
-	let!(:textdec_bytea){ PG::TextDecoder::Bytea.new name: 'BYTEA', oid: 17 }
-	let!(:binarydec_float){ PG::BinaryDecoder::Float.new name: 'FLOAT8', oid: 701, format: 1 }
-	let!(:pass_through_type) do
-		type = Class.new(PG::SimpleDecoder) do
-			def decode(*v)
-				v
-			end
-		end.new
-		type.oid = 1082
-		type.format = 0
-		type.name = 'pass_through'
-		type
-	end
-
-	let!(:tm) do
-		tm = PG::TypeMapByOid.new
-		tm.add_coder textdec_int
-		tm.add_coder textdec_float
-		tm.add_coder binarydec_float
-		tm.add_coder pass_through_type
-		tm
-	end
-
-	it "should retrieve it's conversions" do
-		expect( tm.coders ).to eq( [
-			textdec_int,
-			textdec_float,
-			pass_through_type,
-			binarydec_float,
-		] )
-	end
-
-	it "should allow deletion of coders" do
-		expect( tm.rm_coder 0, 701 ).to eq(textdec_float)
-		expect( tm.rm_coder 0, 701 ).to eq(nil)
-		expect( tm.rm_coder 1, 701 ).to eq(binarydec_float)
-		expect( tm.coders ).to eq( [
-			textdec_int,
-			pass_through_type,
-		] )
-	end
-
-	it "should check format when deleting coders" do
-		expect{ tm.rm_coder 2, 123 }.to raise_error(ArgumentError)
-		expect{ tm.rm_coder -1, 123 }.to raise_error(ArgumentError)
-	end
-
-	it "should check format when adding coders" do
-		textdec_int.format = 2
-		expect{ tm.add_coder textdec_int }.to raise_error(ArgumentError)
-		textdec_int.format = -1
-		expect{ tm.add_coder textdec_int }.to raise_error(ArgumentError)
-	end
-
-	it "should check coder type when adding coders" do
-		expect{ tm.add_coder :dummy }.to raise_error(ArgumentError)
-	end
-
-	it "should allow reading and writing max_rows_for_online_lookup" do
-		expect( tm.max_rows_for_online_lookup ).to eq(10)
-		tm.max_rows_for_online_lookup = 5
-		expect( tm.max_rows_for_online_lookup ).to eq(5)
-	end
-
-	it "should allow building new TypeMapByColumn for a given result" do
-		res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		tm2 = tm.build_column_map(res)
-		expect( tm2 ).to be_a_kind_of(PG::TypeMapByColumn)
-		expect( tm2.coders ).to eq( [textdec_int, nil, textdec_float, pass_through_type] )
-	end
-
-	it "forwards result value conversions to another TypeMapByOid as #default_type_map" do
-		# One run with implicit built TypeMapByColumn and another with online lookup
-		# for each type map.
-		[[0, 0], [0, 10], [10, 0], [10, 10]].each do |max_rows1, max_rows2|
-			tm1 = PG::TypeMapByOid.new
-			tm1.add_coder PG::TextDecoder::Integer.new name: 'INT2', oid: 21
-			tm1.max_rows_for_online_lookup = max_rows1
-
-			tm2 = PG::TypeMapByOid.new
-			tm2.add_coder PG::TextDecoder::Integer.new name: 'INT4', oid: 23
-			tm2.max_rows_for_online_lookup = max_rows2
-			tm2.default_type_map = tm1
-
-			res = @conn.exec( "SELECT '1'::INT4, '2'::INT2, '3'::INT8" ).map_types!( tm2 )
-
-			expect( res.getvalue(0,0) ).to eq( 1 ) # tm2
-			expect( res.getvalue(0,1) ).to eq( 2 ) # tm1
-			expect( res.getvalue(0,2) ).to eq( "3" ) # TypeMapAllStrings
-		end
-	end
-
-	#
-	# Decoding Examples text format
-	#
-
-	it "should allow mixed type conversions in text format" do
-		res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		res.type_map = tm
-		expect( res.values ).to eq( [[1, 'a', 2.0, ['2013-06-30', 0, 3] ]] )
-	end
-
-	it "should build a TypeMapByColumn when assigned and the number of rows is high enough" do
-		res = @conn.exec( "SELECT generate_series(1,20), 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		res.type_map = tm
-		expect( res.type_map ).to be_kind_of( PG::TypeMapByColumn )
-		expect( res.type_map.coders ).to eq( [textdec_int, nil, textdec_float, pass_through_type] )
-	end
-
-	it "should use TypeMapByOid for online lookup and the number of rows is low enough" do
-		res = @conn.exec( "SELECT 1, 'a', 2.0::FLOAT, '2013-06-30'::DATE" )
-		res.type_map = tm
-		expect( res.type_map ).to be_kind_of( PG::TypeMapByOid )
-	end
-
-	#
-	# Decoding Examples binary format
-	#
-
-	it "should allow mixed type conversions in binary format" do
-		res = @conn.exec_params( "SELECT 1, 2.0::FLOAT", [], 1 )
-		res.type_map = tm
-		expect( res.values ).to eq( [["\x00\x00\x00\x01", 2.0 ]] )
-	end
-
-	#
-	# Encoding Examples
-	#
-
-	it "should raise an error used for query params" do
-		expect{
-			@conn.exec_params( "SELECT $1", [5], 0, tm )
-		}.to raise_error(NotImplementedError, /not suitable to map query params/)
-	end
-
-end

data/spec/pg/type_map_in_ruby_spec.rb

@@ -1,164 +0,0 @@
-#!/usr/bin/env rspec
-# encoding: utf-8
-
-require_relative '../helpers'
-
-require 'pg'
-
-
-describe PG::TypeMapInRuby do
-
-	context "result values" do
-		it "should be usable non-derived" do
-			tm = PG::TypeMapInRuby.new
-			res = @conn.exec("select 5").map_types!(tm)
-			expect( res.getvalue(0,0) ).to eq( "5" )
-		end
-
-		it "should call derived result mapping methods" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				attr_reader :fit_to_result_args
-
-				def fit_to_result(*args)
-					@fit_to_result_args = args
-					self
-				end
-
-				def typecast_result_value(*args)
-					[args, super]
-				end
-			end.new
-
-			res = @conn.exec("select 5,6").map_types!(tm)
-			expect( res.getvalue(0,1) ).to eq( [[res, 0, 1], "6"] )
-			expect( tm.fit_to_result_args ).to eq( [res] )
-		end
-
-		it "should accept only a type map object from fit_to_result" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				def fit_to_result(*args)
-					:invalid
-				end
-			end.new
-
-			res = @conn.exec("select 5,6")
-			expect{ res.map_types!(tm) }.to raise_error(TypeError, /kind of PG::TypeMap/)
-		end
-	end
-
-	context "query bind params" do
-		it "should be usable non-derived" do
-			tm = PG::TypeMapInRuby.new
-			res = @conn.exec_params("select $1::int, $2::text", [5, 6], 0, tm)
-			expect( res.values ).to eq( [["5", "6"]] )
-		end
-
-		it "should call derived param mapping methods" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				attr_reader :fit_to_query_args
-				attr_reader :typecast_query_param_args
-
-				def fit_to_query(params)
-					@fit_to_query_args = params
-					@typecast_query_param_args = []
-					self
-				end
-
-				def typecast_query_param(*args)
-					@typecast_query_param_args << [args, super]
-					PG::TextEncoder::Integer.new name: 'INT4', oid: 23
-				end
-			end.new
-
-			res = @conn.exec_params("select $1, $2", [5, 6], 0, tm)
-			expect( res.ftype(0) ).to eq( 23 )
-			expect( tm.fit_to_query_args ).to eq( [5, 6] )
-			expect( tm.typecast_query_param_args ).to eq( [[[5, 0], nil], [[6, 1], nil]] )
-		end
-	end
-
-	context "put_copy_data" do
-		it "should be usable non-derived" do
-			tm = PG::TypeMapInRuby.new
-			ce = PG::TextEncoder::CopyRow.new type_map: tm
-			res = ce.encode([5, 6])
-			expect( res ).to eq( "5\t6\n" )
-		end
-
-		it "should call derived data mapping methods" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				attr_reader :fit_to_query_args
-				attr_reader :typecast_query_param_args
-
-				def fit_to_query(params)
-					@fit_to_query_args = params
-					@typecast_query_param_args = []
-					self
-				end
-
-				def typecast_query_param(*args)
-					@typecast_query_param_args << [args, super]
-					PG::TextEncoder::Integer.new name: 'INT4', oid: 23
-				end
-			end.new
-
-			ce = PG::TextEncoder::CopyRow.new type_map: tm
-			res = ce.encode([5, 6])
-			expect( res ).to eq( "5\t6\n" )
-			expect( tm.fit_to_query_args ).to eq( [5, 6] )
-			expect( tm.typecast_query_param_args ).to eq( [[[5, 0], nil], [[6, 1], nil]] )
-		end
-
-		it "shouldn't accept invalid return from typecast_query_param" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				def typecast_query_param(*args)
-					:invalid
-				end
-			end.new
-
-			ce = PG::TextEncoder::CopyRow.new type_map: tm
-			expect{ ce.encode([5, 6]) }.to raise_error(TypeError, /nil or kind of PG::Coder/)
-		end
-	end
-
-	context "get_copy_data" do
-		it "should be usable non-derived" do
-			tm = PG::TypeMapInRuby.new
-			ce = PG::TextDecoder::CopyRow.new type_map: tm
-			res = ce.decode("5\t6\n")
-			expect( res ).to eq( ["5", "6"] )
-		end
-
-		it "should call derived data mapping methods" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				attr_reader :fit_to_copy_get_args
-
-				def fit_to_copy_get(*args)
-					@fit_to_copy_get_args = args
-					0
-				end
-
-				def typecast_copy_get(field_str, fieldno, format, enc)
-					[field_str, fieldno, format, enc, super]
-				end
-			end.new
-
-			ce = PG::TextDecoder::CopyRow.new type_map: tm
-			res = ce.decode("5\t6\n")
-			expect( tm.fit_to_copy_get_args ).to eq( [] )
-			expect( res ).to eq( [["5", 0, 0, Encoding::UTF_8, "5"], ["6", 1, 0, Encoding::UTF_8, "6"]] )
-		end
-
-		it "shouldn't accept invalid return from fit_to_copy_get" do
-			tm = Class.new(PG::TypeMapInRuby) do
-				def fit_to_copy_get
-					:invalid
-				end
-			end.new
-
-			ce = PG::TextDecoder::CopyRow.new type_map: tm
-			expect{ ce.decode("5\t6\n") }.to raise_error(TypeError, /kind of Integer/)
-		end
-	end
-
-end

data/spec/pg/type_map_spec.rb

@@ -1,22 +0,0 @@
-#!/usr/bin/env rspec
-# encoding: utf-8
-
-require_relative '../helpers'
-
-require 'pg'
-
-
-describe PG::TypeMap do
-	let!(:tm){ PG::TypeMap.new }
-
-	it "should raise an error when used for param type casts" do
-		expect{
-			@conn.exec_params( "SELECT $1", [5], 0, tm )
-		}.to raise_error(NotImplementedError, /not suitable to map query params/)
-	end
-
-	it "should raise an error when used for result type casts" do
-		res = @conn.exec( "SELECT 1" )
-		expect{ res.map_types!(tm) }.to raise_error(NotImplementedError, /not suitable to map result values/)
-	end
-end