pg 0.18.0.pre20140820094244 → 0.18.0.pre20141017155815

data/spec/pg/connection_spec.rb

@@ -229,6 +229,8 @@ describe PG::Connection do
 	end
 
 	it "can stop a thread that runs a blocking query with async_exec" do
+		pending "this does not work on Rubinius" if RUBY_ENGINE=='rbx'
+
 		start = Time.now
 		t = Thread.new do
 			@conn.async_exec( 'select pg_sleep(10)' )
@@ -240,7 +242,7 @@ describe PG::Connection do
 		expect( (Time.now - start) ).to be < 10
 	end
 
-	it "should work together with signal handlers" do
+	it "should work together with signal handlers", :unix do
 		signal_received = false
 		trap 'USR1' do
 			signal_received = true
@@ -271,15 +273,19 @@ describe PG::Connection do
 		res = nil
 		@conn.exec( "CREATE TABLE pie ( flavor TEXT )" )
 
-		expect {
-			res = @conn.transaction do
-				@conn.exec( "INSERT INTO pie VALUES ('rhubarb'), ('cherry'), ('schizophrenia')" )
-				raise "Oh noes! All pie is gone!"
-			end
-		}.to raise_exception( RuntimeError, /all pie is gone/i )
+		begin
+			expect {
+				res = @conn.transaction do
+					@conn.exec( "INSERT INTO pie VALUES ('rhubarb'), ('cherry'), ('schizophrenia')" )
+					raise "Oh noes! All pie is gone!"
+				end
+			}.to raise_exception( RuntimeError, /all pie is gone/i )
 
-		res = @conn.exec( "SELECT * FROM pie" )
-		expect( res.ntuples ).to eq( 0 )
+			res = @conn.exec( "SELECT * FROM pie" )
+			expect( res.ntuples ).to eq( 0 )
+		ensure
+			@conn.exec( "DROP TABLE pie" )
+		end
 	end
 
 	it "returns the block result from Connection#transaction" do
@@ -324,6 +330,29 @@ describe PG::Connection do
 		expect( res.values ).to eq( [ ['Wally'], ['Sally'] ] )
 	end
 
+	it "supports hash form parameters for #exec_params" do
+		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 ] )
+		expect( res.values ).to eq( [["\\x00ff", nil]] )
+		expect( result_typenames(res) ).to eq( ['bytea', 'bytea'] )
+	end
+
+	it "should work with arbitrary number of params" do
+		begin
+			3.step( 12, 0.2 ) do |exp|
+				num_params = (2 ** exp).to_i
+				sql = num_params.times.map{|n| "$#{n+1}::INT" }.join(",")
+				params = num_params.times.to_a
+				res = @conn.exec_params( "SELECT #{sql}", params )
+				expect( res.nfields ).to eq( num_params )
+				expect( res.values ).to eq( [num_params.times.map(&:to_s)] )
+			end
+		rescue PG::ProgramLimitExceeded
+			# Stop silently if the server complains about too many params
+		end
+	end
 
 	it "can wait for NOTIFY events" do
 		@conn.exec( 'ROLLBACK' )
@@ -478,7 +507,7 @@ describe PG::Connection do
 		expect( @conn ).to still_be_usable
 	end
 
-	it "can handle server errors in #copy_data for output" do
+	it "can handle server errors in #copy_data for output", :postgresql_90 do
 		@conn.exec "ROLLBACK"
 		@conn.transaction do
 			@conn.exec( "CREATE FUNCTION errfunc() RETURNS int AS $$ BEGIN RAISE 'test-error'; END; $$ LANGUAGE plpgsql;" )
@@ -590,22 +619,35 @@ describe PG::Connection do
 		expect( described_class.encrypt_password("postgres", "postgres") ).to match( /\S+/ )
 	end
 
+	it "can return the default connection options" do
+		expect( described_class.conndefaults ).to be_a( Array )
+		expect( described_class.conndefaults ).to all( be_a(Hash) )
+		expect( described_class.conndefaults[0] ).to include( :keyword, :label, :dispchar, :dispsize )
+		expect( @conn.conndefaults ).to eq( described_class.conndefaults )
+	end
+
+	it "can return the default connection options as a Hash" do
+		expect( described_class.conndefaults_hash ).to be_a( Hash )
+		expect( described_class.conndefaults_hash ).to include( :user, :password, :dbname, :host, :port )
+		expect( described_class.conndefaults_hash[:port] ).to eq( '54321' )
+		expect( @conn.conndefaults_hash ).to eq( described_class.conndefaults_hash )
+	end
 
-	it "can return the connection's connection options" do
+	it "can return the connection's connection options", :postgresql_93 do
 		expect( @conn.conninfo ).to be_a( Array )
 		expect( @conn.conninfo ).to all( be_a(Hash) )
 		expect( @conn.conninfo[0] ).to include( :keyword, :label, :dispchar, :dispsize )
 	end
 
 
-	it "can return the connection's connection options as a Hash" do
+	it "can return the connection's connection options as a Hash", :postgresql_93 do
 		expect( @conn.conninfo_hash ).to be_a( Hash )
 		expect( @conn.conninfo_hash ).to include( :user, :password, :connect_timeout, :dbname, :host )
 		expect( @conn.conninfo_hash[:dbname] ).to eq( 'test' )
 	end
 
 
-	it "honors the connect_timeout connection parameter" do
+	it "honors the connect_timeout connection parameter", :postgresql_93 do
 		conn = PG.connect( port: @port, dbname: 'test', connect_timeout: 11 )
 		begin
 			expect( conn.conninfo_hash[:connect_timeout] ).to eq( "11" )
@@ -1097,6 +1139,7 @@ describe PG::Connection do
 					res = conn.exec( "SELECT foo FROM defaultinternaltest" )
 					expect( res[0]['foo'].encoding ).to eq( Encoding::UTF_8 )
 				ensure
+					conn.exec( "DROP TABLE defaultinternaltest" )
 					conn.finish if conn
 					Encoding.default_internal = prev_encoding
 				end
@@ -1139,6 +1182,21 @@ describe PG::Connection do
 			conn.finish if conn
 		end
 
+		it "handles clearing result in or after set_notice_receiver", :postgresql_90 do
+			r = nil
+			@conn.set_notice_receiver do |result|
+				r = result
+				expect( r.cleared? ).to eq(false)
+			end
+			@conn.exec "do $$ BEGIN RAISE NOTICE 'foo'; END; $$ LANGUAGE plpgsql;"
+			sleep 0.2
+			expect( r ).to be_a( PG::Result )
+			expect( r.cleared? ).to eq(true)
+			expect( r.autoclear? ).to eq(true)
+			r.clear
+			@conn.set_notice_receiver
+		end
+
 		it "receives properly encoded messages in the notice callbacks", :postgresql_90 do
 			[:receiver, :processor].each do |kind|
 				notices = []
@@ -1226,4 +1284,165 @@ describe PG::Connection do
 			t.join
 		end
 	end
+
+	describe "type casting" do
+		it "should raise an error on invalid param mapping" do
+			expect{
+				@conn.exec_params( "SELECT 1", [], nil, :invalid )
+			}.to raise_error(TypeError)
+		end
+
+		it "should return nil if no type mapping is set" do
+			expect( @conn.type_map_for_queries ).to be_nil
+			expect( @conn.type_map_for_results ).to be_nil
+		end
+
+		it "shouldn't type map params unless requested" do
+			expect{
+				@conn.exec_params( "SELECT $1", [5] )
+			}.to raise_error(PG::IndeterminateDatatype)
+		end
+
+		it "should raise an error on invalid encoder to put_copy_data" do
+			expect{
+				@conn.put_copy_data [1], :invalid
+			}.to raise_error(TypeError)
+		end
+
+		it "can type cast parameters to put_copy_data with explicit encoder" do
+			tm = PG::TypeMapByColumn.new [nil]
+			row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
+
+			@conn.exec( "CREATE TEMP TABLE copytable (col1 TEXT)" )
+			res2 = @conn.copy_data( "COPY copytable FROM STDOUT" ) do |res|
+				@conn.put_copy_data [1], row_encoder
+				@conn.put_copy_data ["2"], row_encoder
+			end
+
+			res2 = @conn.copy_data( "COPY copytable FROM STDOUT", row_encoder ) do |res|
+				@conn.put_copy_data [3]
+				@conn.put_copy_data ["4"]
+			end
+
+			res = @conn.exec( "SELECT * FROM copytable ORDER BY col1" )
+			expect( res.values ).to eq( [["1"], ["2"], ["3"], ["4"]] )
+		end
+
+		context "with default query type map" do
+			before :each do
+				@conn2 = described_class.new(@conninfo)
+				tm = PG::TypeMapByMriType.new
+				tm['T_FIXNUM'] = PG::TextEncoder::Integer.new oid: 20
+				@conn2.type_map_for_queries = tm
+
+				row_encoder = PG::TextEncoder::CopyRow.new type_map: tm
+				@conn2.encoder_for_put_copy_data = row_encoder
+			end
+			after :each do
+				@conn2.close
+			end
+
+			it "should respect a type mapping for params and it's OID and format code" do
+				res = @conn2.exec_params( "SELECT $1", [5] )
+				expect( res.values ).to eq( [["5"]] )
+				expect( res.ftype(0) ).to eq( 20 )
+			end
+
+			it "should return the current type mapping" do
+				expect( @conn2.type_map_for_queries ).to be_kind_of(PG::TypeMapByMriType)
+			end
+
+			it "should work with arbitrary number of params in conjunction with type casting" do
+				begin
+					3.step( 12, 0.2 ) do |exp|
+						num_params = (2 ** exp).to_i
+						sql = num_params.times.map{|n| "$#{n+1}" }.join(",")
+						params = num_params.times.to_a
+						res = @conn2.exec_params( "SELECT #{sql}", params )
+						expect( res.nfields ).to eq( num_params )
+						expect( res.values ).to eq( [num_params.times.map(&:to_s)] )
+					end
+				rescue PG::ProgramLimitExceeded
+					# Stop silently as soon the server complains about too many params
+				end
+			end
+
+			it "can process #copy_data input queries with row encoder" do
+				@conn2.exec( "CREATE TEMP TABLE copytable (col1 TEXT)" )
+				res2 = @conn2.copy_data( "COPY copytable FROM STDOUT" ) do |res|
+					@conn2.put_copy_data [1]
+					@conn2.put_copy_data ["2"]
+				end
+
+				res = @conn2.exec( "SELECT * FROM copytable ORDER BY col1" )
+				expect( res.values ).to eq( [["1"], ["2"]] )
+			end
+		end
+
+		context "with default result type map" do
+			before :each do
+				@conn2 = described_class.new(@conninfo)
+				tm = PG::TypeMapByOid.new
+				tm.add_coder PG::TextDecoder::Integer.new oid: 23, format: 0
+				@conn2.type_map_for_results = tm
+
+				row_decoder = PG::TextDecoder::CopyRow.new
+				@conn2.decoder_for_get_copy_data = row_decoder
+			end
+			after :each do
+				@conn2.close
+			end
+
+			it "should respect a type mapping for result" do
+				res = @conn2.exec_params( "SELECT $1::INT", ["5"] )
+				expect( res.values ).to eq( [[5]] )
+			end
+
+			it "should return the current type mapping" do
+				expect( @conn2.type_map_for_results ).to be_kind_of(PG::TypeMapByOid)
+			end
+
+			it "should work with arbitrary number of params in conjunction with type casting" do
+				begin
+					3.step( 12, 0.2 ) do |exp|
+						num_params = (2 ** exp).to_i
+						sql = num_params.times.map{|n| "$#{n+1}::INT" }.join(",")
+						params = num_params.times.to_a
+						res = @conn2.exec_params( "SELECT #{sql}", params )
+						expect( res.nfields ).to eq( num_params )
+						expect( res.values ).to eq( [num_params.times.to_a] )
+					end
+				rescue PG::ProgramLimitExceeded
+					# Stop silently as soon the server complains about too many params
+				end
+			end
+
+			it "can process #copy_data output with row decoder" do
+				rows = []
+				res2 = @conn2.copy_data( "COPY (SELECT 1 UNION ALL SELECT 2) TO STDOUT" ) do |res|
+					while row=@conn2.get_copy_data
+						rows << row
+					end
+				end
+				expect( rows ).to eq( [["1"], ["2"]] )
+			end
+
+			it "can type cast #copy_data output with explicit decoder" do
+				tm = PG::TypeMapByColumn.new [PG::TextDecoder::Integer.new]
+				row_decoder = PG::TextDecoder::CopyRow.new type_map: tm
+				rows = []
+				@conn.copy_data( "COPY (SELECT 1 UNION ALL SELECT 2) TO STDOUT", row_decoder ) do |res|
+					while row=@conn.get_copy_data
+						rows << row
+					end
+				end
+				@conn.copy_data( "COPY (SELECT 3 UNION ALL SELECT 4) TO STDOUT" ) do |res|
+					while row=@conn.get_copy_data( false, row_decoder )
+						rows << row
+					end
+				end
+				expect( rows ).to eq( [[1], [2], [3], [4]] )
+			end
+		end
+	end
 end

data/spec/pg/result_spec.rb

@@ -320,4 +320,56 @@ describe PG::Result do
 			expect( error.result ).to eq( nil )
 		}
 	end
+
+	it "does not clear the result itself" do
+		r = @conn.exec "select 1"
+		expect( r.autoclear? ).to eq(false)
+		expect( r.cleared? ).to eq(false)
+		r.clear
+		expect( r.cleared? ).to eq(true)
+	end
+
+	context 'result value conversions with TypeMapByColumn' do
+		let!(:textdec_int){ PG::TextDecoder::Integer.new name: 'INT4', oid: 23 }
+		let!(:textdec_float){ PG::TextDecoder::Float.new name: 'FLOAT4', oid: 700 }
+
+		it "should allow reading, assigning and diabling type conversions" do
+			res = @conn.exec( "SELECT 123" )
+			expect( res.type_map ).to be_nil
+			res.type_map = PG::TypeMapByColumn.new [textdec_int]
+			expect( res.type_map ).to be_an_instance_of(PG::TypeMapByColumn)
+			expect( res.type_map.coders ).to eq( [textdec_int] )
+			res.type_map = PG::TypeMapByColumn.new [textdec_float]
+			expect( res.type_map.coders ).to eq( [textdec_float] )
+			res.type_map = nil
+			expect( res.type_map ).to be_nil
+		end
+
+		it "should be applied to all value retrieving methods" do
+			res = @conn.exec( "SELECT 123 as f" )
+			res.type_map = PG::TypeMapByColumn.new [textdec_int]
+			expect( res.values ).to eq( [[123]] )
+			expect( res.getvalue(0,0) ).to eq( 123 )
+			expect( res[0] ).to eq( {'f' => 123 } )
+			expect( res.enum_for(:each_row).to_a ).to eq( [[123]] )
+			expect( res.enum_for(:each).to_a ).to eq( [{'f' => 123}] )
+			expect( res.column_values(0) ).to eq( [123] )
+			expect( res.field_values('f') ).to eq( [123] )
+		end
+
+		it "should be usable for several querys" do
+			colmap = PG::TypeMapByColumn.new [textdec_int]
+			res = @conn.exec( "SELECT 123" )
+			res.type_map = colmap
+			expect( res.values ).to eq( [[123]] )
+			res = @conn.exec( "SELECT 456" )
+			res.type_map = colmap
+			expect( res.values ).to eq( [[456]] )
+		end
+
+		it "shouldn't allow invalid type maps" do
+			res = @conn.exec( "SELECT 1" )
+			expect{ res.type_map = 1 }.to raise_error(TypeError)
+		end
+	end
 end

data/spec/pg/type_map_by_column_spec.rb

@@ -0,0 +1,135 @@
+#!/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
+
+
+	#
+	# 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
+
+	#
+	# 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
+
+	#
+	# 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