pg 1.2.0-x86-mingw32 → 1.3.0.rc1-x86-mingw32

data/spec/pg/tuple_spec.rb

@@ -1,333 +0,0 @@
-# -*- rspec -*-
-# encoding: utf-8
-
-require_relative '../helpers'
-require 'pg'
-require 'objspace'
-
-describe PG::Tuple do
-	let!(:typemap) { PG::BasicTypeMapForResults.new(@conn) }
-	let!(:result2x2) { @conn.exec( "VALUES(1, 'a'), (2, 'b')" ) }
-	let!(:result2x2sym) { @conn.exec( "VALUES(1, 'a'), (2, 'b')" ).field_names_as(:symbol) }
-	let!(:result2x3cast) do
-		@conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" )
-			.map_types!(typemap)
-	end
-	let!(:result2x3symcast) do
-		@conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" )
-			.map_types!(typemap)
-			.field_names_as(:symbol)
-	end
-	let!(:tuple0) { result2x2.tuple(0) }
-	let!(:tuple0sym) { result2x2sym.tuple(0) }
-	let!(:tuple1) { result2x2.tuple(1) }
-	let!(:tuple1sym) { result2x2sym.tuple(1) }
-	let!(:tuple2) { result2x3cast.tuple(0) }
-	let!(:tuple2sym) { result2x3symcast.tuple(0) }
-	let!(:tuple3) { str = Marshal.dump(result2x3cast.tuple(1)); Marshal.load(str) }
-	let!(:tuple_empty) { PG::Tuple.new }
-
-	describe "[]" do
-		it "returns nil for invalid keys" do
-			expect( tuple0["x"] ).to be_nil
-			expect( tuple0[0.5] ).to be_nil
-			expect( tuple0[2] ).to be_nil
-			expect( tuple0[-3] ).to be_nil
-			expect( tuple2[-4] ).to be_nil
-			expect{ tuple_empty[0] }.to raise_error(TypeError)
-		end
-
-		it "supports array like access" do
-			expect( tuple0[0] ).to eq( "1" )
-			expect( tuple0[1] ).to eq( "a" )
-			expect( tuple1[0] ).to eq( "2" )
-			expect( tuple1[1] ).to eq( "b" )
-			expect( tuple2[0] ).to eq( 1 )
-			expect( tuple2[1] ).to eq( true )
-			expect( tuple2[2] ).to eq( "3" )
-			expect( tuple3[0] ).to eq( 2 )
-			expect( tuple3[1] ).to eq( false )
-			expect( tuple3[2] ).to eq( "4" )
-		end
-
-		it "supports negative indices" do
-			expect( tuple0[-2] ).to eq( "1" )
-			expect( tuple0[-1] ).to eq( "a" )
-			expect( tuple2[-3] ).to eq( 1 )
-			expect( tuple2[-2] ).to eq( true )
-			expect( tuple2[-1] ).to eq( "3" )
-		end
-
-		it "supports hash like access" do
-			expect( tuple0["column1"] ).to eq( "1" )
-			expect( tuple0["column2"] ).to eq( "a" )
-			expect( tuple2["a"] ).to eq( 1 )
-			expect( tuple2["b"] ).to eq( "3" )
-			expect( tuple0[:b] ).to be_nil
-			expect( tuple0["x"] ).to be_nil
-		end
-
-		it "supports hash like access with symbols" do
-			expect( tuple0sym[:column1] ).to eq( "1" )
-			expect( tuple0sym[:column2] ).to eq( "a" )
-			expect( tuple2sym[:a] ).to eq( 1 )
-			expect( tuple2sym[:b] ).to eq( "3" )
-			expect( tuple2sym["b"] ).to be_nil
-			expect( tuple0sym[:x] ).to be_nil
-		end
-
-		it "casts lazy and caches result" do
-			a = []
-			deco = Class.new(PG::SimpleDecoder) do
-				define_method(:decode) do |*args|
-					a << args
-					args.last
-				end
-			end.new
-
-			result2x2.map_types!(PG::TypeMapByColumn.new([deco, deco]))
-			t = result2x2.tuple(1)
-
-			# cast and cache at first call to [0]
-			a.clear
-			expect( t[0] ).to eq( 0 )
-			expect( a ).to eq([["2", 1, 0]])
-
-			# use cache at second call to [0]
-			a.clear
-			expect( t[0] ).to eq( 0 )
-			expect( a ).to eq([])
-
-			# cast and cache at first call to [1]
-			a.clear
-			expect( t[1] ).to eq( 1 )
-			expect( a ).to eq([["b", 1, 1]])
-		end
-	end
-
-	describe "fetch" do
-		it "raises proper errors for invalid keys" do
-			expect{ tuple0.fetch("x") }.to raise_error(KeyError)
-			expect{ tuple0.fetch(0.5) }.to raise_error(KeyError)
-			expect{ tuple0.fetch(2) }.to raise_error(IndexError)
-			expect{ tuple0.fetch(-3) }.to raise_error(IndexError)
-			expect{ tuple0.fetch(-3) }.to raise_error(IndexError)
-			expect{ tuple2.fetch(-4) }.to raise_error(IndexError)
-			expect{ tuple_empty[0] }.to raise_error(TypeError)
-		end
-
-		it "supports array like access" do
-			expect( tuple0.fetch(0) ).to eq( "1" )
-			expect( tuple0.fetch(1) ).to eq( "a" )
-			expect( tuple2.fetch(0) ).to eq( 1 )
-			expect( tuple2.fetch(1) ).to eq( true )
-			expect( tuple2.fetch(2) ).to eq( "3" )
-		end
-
-		it "supports default value for indices" do
-			expect( tuple0.fetch(2, 42) ).to eq( 42 )
-			expect( tuple0.fetch(2){43} ).to eq( 43 )
-		end
-
-		it "supports negative indices" do
-			expect( tuple0.fetch(-2) ).to eq( "1" )
-			expect( tuple0.fetch(-1) ).to eq( "a" )
-			expect( tuple2.fetch(-3) ).to eq( 1 )
-			expect( tuple2.fetch(-2) ).to eq( true )
-			expect( tuple2.fetch(-1) ).to eq( "3" )
-		end
-
-		it "supports hash like access" do
-			expect( tuple0.fetch("column1") ).to eq( "1" )
-			expect( tuple0.fetch("column2") ).to eq( "a" )
-			expect( tuple2.fetch("a") ).to eq( 1 )
-			expect( tuple2.fetch("b") ).to eq( "3" )
-		end
-
-		it "supports default value for name keys" do
-			expect( tuple0.fetch("x", "defa") ).to eq("defa")
-			expect( tuple0.fetch("x"){"defa"} ).to eq("defa")
-		end
-	end
-
-	describe "each" do
-		it "can be used as an enumerator" do
-			expect( tuple0.each ).to be_kind_of(Enumerator)
-			expect( tuple0.each.to_a ).to eq( [["column1", "1"], ["column2", "a"]] )
-			expect( tuple1.each.to_a ).to eq( [["column1", "2"], ["column2", "b"]] )
-			expect( tuple2.each.to_a ).to eq( [["a", 1], ["b", true], ["b", "3"]] )
-			expect( tuple3.each.to_a ).to eq( [["a", 2], ["b", false], ["b", "4"]] )
-			expect{ tuple_empty.each }.to raise_error(TypeError)
-		end
-
-		it "can be used as an enumerator with symbols" do
-			expect( tuple0sym.each ).to be_kind_of(Enumerator)
-			expect( tuple0sym.each.to_a ).to eq( [[:column1, "1"], [:column2, "a"]] )
-			expect( tuple2sym.each.to_a ).to eq( [[:a, 1], [:b, true], [:b, "3"]] )
-		end
-
-		it "can be used with block" do
-			a = []
-			tuple0.each do |*v|
-				a << v
-			end
-			expect( a ).to eq( [["column1", "1"], ["column2", "a"]] )
-		end
-	end
-
-	describe "each_value" do
-		it "can be used as an enumerator" do
-			expect( tuple0.each_value ).to be_kind_of(Enumerator)
-			expect( tuple0.each_value.to_a ).to eq( ["1", "a"] )
-			expect( tuple1.each_value.to_a ).to eq( ["2", "b"] )
-			expect( tuple2.each_value.to_a ).to eq( [1, true, "3"] )
-			expect( tuple3.each_value.to_a ).to eq( [2, false, "4"] )
-			expect{ tuple_empty.each_value }.to raise_error(TypeError)
-		end
-
-		it "can be used with block" do
-			a = []
-			tuple0.each_value do |v|
-				a << v
-			end
-			expect( a ).to eq( ["1", "a"] )
-		end
-	end
-
-	it "responds to values" do
-		expect( tuple0.values ).to eq( ["1", "a"] )
-		expect( tuple3.values ).to eq( [2, false, "4"] )
-		expect{ tuple_empty.values }.to raise_error(TypeError)
-	end
-
-	it "responds to key?" do
-		expect( tuple1.key?("column1") ).to eq( true )
-		expect( tuple1.key?(:column1) ).to eq( false )
-		expect( tuple1.key?("other") ).to eq( false )
-		expect( tuple1.has_key?("column1") ).to eq( true )
-		expect( tuple1.has_key?("other") ).to eq( false )
-	end
-
-	it "responds to key? as symbol" do
-		expect( tuple1sym.key?(:column1) ).to eq( true )
-		expect( tuple1sym.key?("column1") ).to eq( false )
-		expect( tuple1sym.key?(:other) ).to eq( false )
-		expect( tuple1sym.has_key?(:column1) ).to eq( true )
-		expect( tuple1sym.has_key?(:other) ).to eq( false )
-	end
-
-	it "responds to keys" do
-		expect( tuple0.keys ).to eq( ["column1", "column2"] )
-		expect( tuple2.keys ).to eq( ["a", "b", "b"] )
-	end
-
-	it "responds to keys as symbol" do
-		expect( tuple0sym.keys ).to eq( [:column1, :column2] )
-		expect( tuple2sym.keys ).to eq( [:a, :b, :b] )
-	end
-
-	describe "each_key" do
-		it "can be used as an enumerator" do
-			expect( tuple0.each_key ).to be_kind_of(Enumerator)
-			expect( tuple0.each_key.to_a ).to eq( ["column1", "column2"] )
-			expect( tuple2.each_key.to_a ).to eq( ["a", "b", "b"] )
-		end
-
-		it "can be used with block" do
-			a = []
-			tuple0.each_key do |v|
-				a << v
-			end
-			expect( a ).to eq( ["column1", "column2"] )
-		end
-	end
-
-	it "responds to length" do
-		expect( tuple0.length ).to eq( 2 )
-		expect( tuple0.size ).to eq( 2 )
-		expect( tuple2.size ).to eq( 3 )
-	end
-
-	it "responds to index" do
-		expect( tuple0.index("column1") ).to eq( 0 )
-		expect( tuple0.index(:column1) ).to eq( nil )
-		expect( tuple0.index("column2") ).to eq( 1 )
-		expect( tuple0.index("x") ).to eq( nil )
-		expect( tuple2.index("a") ).to eq( 0 )
-		expect( tuple2.index("b") ).to eq( 2 )
-	end
-
-	it "responds to index with symbol" do
-		expect( tuple0sym.index(:column1) ).to eq( 0 )
-		expect( tuple0sym.index("column1") ).to eq( nil )
-		expect( tuple0sym.index(:column2) ).to eq( 1 )
-		expect( tuple0sym.index(:x) ).to eq( nil )
-		expect( tuple2sym.index(:a) ).to eq( 0 )
-		expect( tuple2sym.index(:b) ).to eq( 2 )
-	end
-
-	it "can be used as Enumerable" do
-		expect( tuple0.to_a ).to eq( [["column1", "1"], ["column2", "a"]] )
-		expect( tuple1.to_a ).to eq( [["column1", "2"], ["column2", "b"]] )
-		expect( tuple2.to_a ).to eq( [["a", 1], ["b", true], ["b", "3"]] )
-		expect( tuple3.to_a ).to eq( [["a", 2], ["b", false], ["b", "4"]] )
-	end
-
-	it "can be marshaled" do
-		[tuple0, tuple1, tuple2, tuple3, tuple0sym, tuple2sym].each do |t1|
-			str = Marshal.dump(t1)
-			t2 = Marshal.load(str)
-
-			expect( t2 ).to be_kind_of(t1.class)
-			expect( t2 ).not_to equal(t1)
-			expect( t2.to_a ).to eq(t1.to_a)
-		end
-	end
-
-	it "passes instance variables when marshaled" do
-		t1 = tuple0
-		t1.instance_variable_set("@a", 4711)
-		str = Marshal.dump(t1)
-		t2 = Marshal.load(str)
-
-		expect( t2.instance_variable_get("@a") ).to eq( 4711 )
-	end
-
-	it "can't be marshaled when empty" do
-		expect{ Marshal.dump(tuple_empty) }.to raise_error(TypeError)
-	end
-
-	it "should give account about memory usage" do
-		expect( ObjectSpace.memsize_of(tuple0) ).to be > 40
-		expect( ObjectSpace.memsize_of(tuple_empty) ).to be > 0
-	end
-
-	it "should override #inspect" do
-		expect( tuple1.inspect ).to eq('#<PG::Tuple column1: "2", column2: "b">')
-		expect( tuple2.inspect ).to eq('#<PG::Tuple a: 1, b: true, b: "3">')
-		expect( tuple2sym.inspect ).to eq('#<PG::Tuple a: 1, b: true, b: "3">')
-		expect{ tuple_empty.inspect }.to raise_error(TypeError)
-	end
-
-	context "with cleared result" do
-		it "should raise an error when non-materialized fields are used" do
-			r = result2x2
-			t = r.tuple(0)
-			t[0] # materialize first field only
-			r.clear
-
-			# second column should fail
-			expect{ t[1] }.to raise_error(PG::Error)
-			expect{ t.fetch(1) }.to raise_error(PG::Error)
-			expect{ t.fetch("column2") }.to raise_error(PG::Error)
-
-			# first column should succeed
-			expect( t[0] ).to eq( "1" )
-			expect( t.fetch(0) ).to eq( "1" )
-			expect( t.fetch("column1") ).to eq( "1" )
-
-			# should fail due to the second column
-			expect{ t.values }.to raise_error(PG::Error)
-		end
-	end
-end

data/spec/pg/type_map_by_class_spec.rb

@@ -1,138 +0,0 @@
-# -*- rspec -*-
-# encoding: utf-8
-
-require_relative '../helpers'
-
-require 'pg'
-
-
-describe PG::TypeMapByClass 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::TypeMapByClass.new
-		tm[Integer] = binaryenc_int
-		tm[Float] = textenc_float
-		tm[Symbol] = pass_through_type
-		tm
-	end
-
-	let!(:raise_class) do
-		Class.new
-	end
-
-	let!(:derived_tm) do
-		tm = Class.new(PG::TypeMapByClass) 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[Integer] = proc{|value| textenc_int }
-		tm[raise_class] = proc{|value| /invalid/ }
-		tm[Array] = :array_type_map_for
-		tm
-	end
-
-	it "should retrieve all conversions" do
-		expect( tm.coders ).to eq( {
-			Integer => binaryenc_int,
-			Float => textenc_float,
-			Symbol => pass_through_type,
-		} )
-	end
-
-	it "should retrieve particular conversions" do
-		expect( tm[Integer] ).to eq(binaryenc_int)
-		expect( tm[Float] ).to eq(textenc_float)
-		expect( tm[Range] ).to be_nil
-		expect( derived_tm[raise_class] ).to be_kind_of(Proc)
-		expect( derived_tm[Array] ).to eq(:array_type_map_for)
-	end
-
-	it "should allow deletion of coders" do
-		tm[Integer] = nil
-		expect( tm[Integer] ).to be_nil
-		expect( tm.coders ).to eq( {
-			Float => textenc_float,
-			Symbol => pass_through_type,
-		} )
-	end
-
-	it "forwards query param conversions to the #default_type_map" do
-		tm1 = PG::TypeMapByColumn.new( [textenc_int, nil, nil] )
-
-		tm2 = PG::TypeMapByClass.new
-		tm2[Integer] = 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 expire the cache after changes to the coders" do
-		res = @conn.exec_params( "SELECT $1", [5], 0, tm )
-		expect( res.ftype(0) ).to eq(20)
-
-		tm[Integer] = textenc_int
-
-		res = @conn.exec_params( "SELECT $1", [5], 0, tm )
-		expect( res.ftype(0) ).to eq(23)
-	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", [raise_class.new], 0, derived_tm )
-		}.to raise_error(TypeError, /invalid type Regexp/)
-	end
-
-	it "should raise error on invalid coder object" do
-		tm[TrueClass] = "dummy"
-		expect{
-			res = @conn.exec_params( "SELECT $1", [true], 0, tm )
-		}.to raise_error(NoMethodError, /undefined method.*call/)
-	end
-end

data/spec/pg/type_map_by_column_spec.rb

@@ -1,226 +0,0 @@
-# -*- 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
-		] )
-	end
-
-	it "should respond to inspect" do
-		cm = PG::TypeMapByColumn.new( [textdec_int, textenc_string, textdec_float, pass_through_type, PG::TextEncoder::Float.new, nil] )
-		expect( cm.inspect ).to eq( "#<PG::TypeMapByColumn INT4:TD TEXT:TE FLOAT4:TD pass_through:BD PG::TextEncoder::Float:TE 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