pg 1.1.0 → 1.2.3

data/spec/pg/connection_spec.rb

@@ -173,7 +173,7 @@ describe PG::Connection do
 		end
 	end
 
-	it "can connect asynchronously", :socket_io do
+	it "can connect asynchronously" do
 		tmpconn = described_class.connect_start( @conninfo )
 		expect( tmpconn ).to be_a( described_class )
 
@@ -182,7 +182,7 @@ describe PG::Connection do
 		tmpconn.finish
 	end
 
-	it "can connect asynchronously for the duration of a block", :socket_io do
+	it "can connect asynchronously for the duration of a block" do
 		conn = nil
 
 		described_class.connect_start(@conninfo) do |tmpconn|
@@ -196,7 +196,7 @@ describe PG::Connection do
 		expect( conn ).to be_finished()
 	end
 
-	context "with async established connection", :socket_io do
+	context "with async established connection" do
 		before :each do
 			@conn2 = described_class.connect_start( @conninfo )
 			wait_for_polling_ok(@conn2)
@@ -228,6 +228,37 @@ describe PG::Connection do
 
 			res = @conn2.query("SELECT 4")
 		end
+
+		it "can use conn.reset_start to restart the connection" do
+			ios = IO.pipe
+			conn = described_class.connect_start( @conninfo )
+			wait_for_polling_ok(conn)
+
+			# Close the two pipe file descriptors, so that the file descriptor of
+			# newly established connection is probably distinct from the previous one.
+			ios.each(&:close)
+			conn.reset_start
+			wait_for_polling_ok(conn, :reset_poll)
+
+			# The new connection should work even when the file descriptor has changed.
+			conn.send_query("SELECT 1")
+			res = wait_for_query_result(conn)
+			expect( res.values ).to eq([["1"]])
+
+			conn.close
+		end
+
+		it "should properly close a socket IO when GC'ed" do
+			# This results in
+			#    Errno::ENOTSOCK: An operation was attempted on something that is not a socket.
+			# on Windows when rb_w32_unwrap_io_handle() isn't called in pgconn_gc_free().
+			5.times do
+				conn = described_class.connect( @conninfo )
+				conn.socket_io.close
+			end
+			GC.start
+			IO.pipe.each(&:close)
+		end
 	end
 
 	it "raises proper error when sending fails" do
@@ -248,7 +279,7 @@ describe PG::Connection do
 		expect( @conn.db ).to eq( "test" )
 		expect( @conn.user ).to be_a_kind_of( String )
 		expect( @conn.pass ).to eq( "" )
-		expect( @conn.port ).to eq( 54321 )
+		expect( @conn.port ).to eq( @port )
 		expect( @conn.tty ).to eq( "" )
 		expect( @conn.options ).to eq( "" )
 	end
@@ -257,7 +288,20 @@ describe PG::Connection do
 		expect( @conn.host ).to eq( "localhost" )
 	end
 
-	EXPECTED_TRACE_OUTPUT = %{
+	it "can set error verbosity" do
+		old = @conn.set_error_verbosity( PG::PQERRORS_TERSE )
+		new = @conn.set_error_verbosity( old )
+		expect( new ).to eq( PG::PQERRORS_TERSE )
+	end
+
+	it "can set error context visibility", :postgresql_96 do
+		old = @conn.set_error_context_visibility( PG::PQSHOW_CONTEXT_NEVER )
+		new = @conn.set_error_context_visibility( old )
+		expect( new ).to eq( PG::PQSHOW_CONTEXT_NEVER )
+	end
+
+	let(:expected_trace_output) do
+		%{
 		To backend> Msg Q
 		To backend> "SELECT 1 AS one"
 		To backend> Msg complete, length 21
@@ -285,6 +329,7 @@ describe PG::Connection do
 		From backend (#4)> 5
 		From backend> T
 		}.gsub( /^\t{2}/, '' ).lstrip
+	end
 
 	it "trace and untrace client-server communication", :unix do
 			# be careful to explicitly close files so that the
@@ -295,10 +340,10 @@ describe PG::Connection do
 			@conn.trace( trace_io )
 			trace_io.close
 
-			res = @conn.exec("SELECT 1 AS one")
+			@conn.exec("SELECT 1 AS one")
 			@conn.untrace
 
-			res = @conn.exec("SELECT 2 AS two")
+			@conn.exec("SELECT 2 AS two")
 
 			trace_data = trace_file.read
 
@@ -310,7 +355,7 @@ describe PG::Connection do
 			#  From backend> T
 			trace_data.sub!( /(From backend> Z\nFrom backend \(#4\)> 5\n){3}/m, '\\1\\1' )
 
-			expect( trace_data ).to eq( EXPECTED_TRACE_OUTPUT )
+			expect( trace_data ).to eq( expected_trace_output )
 		end
 
 	it "allows a query to be cancelled" do
@@ -325,8 +370,6 @@ 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)' )
@@ -340,24 +383,16 @@ describe PG::Connection do
 
 	it "should work together with signal handlers", :unix do
 		signal_received = false
-		trap 'USR1' do
+		trap 'USR2' do
 			signal_received = true
 		end
 
 		Thread.new do
 			sleep 0.1
-			Process.kill("USR1", Process.pid)
+			Process.kill("USR2", Process.pid)
 		end
 		@conn.exec("select pg_sleep(0.3)")
 		expect( signal_received ).to be_truthy
-
-		signal_received = false
-		Thread.new do
-			sleep 0.1
-			Process.kill("USR1", Process.pid)
-		end
-		@conn.async_exec("select pg_sleep(0.3)")
-		expect( signal_received ).to be_truthy
 	end
 
 
@@ -540,7 +575,7 @@ describe PG::Connection do
 		expect( @conn.wait_for_notify( 1 ) ).to be_nil
 		expect( notices.first ).to_not be_nil
 		et = Time.now
-		expect( (et - notices.first[1]) ).to be >= 0.4
+		expect( (et - notices.first[1]) ).to be >= 0.3
 		expect( (et - st) ).to be >= 0.9
 		expect( (et - st) ).to be < 1.4
 	end
@@ -644,7 +679,7 @@ describe PG::Connection do
 				@conn.copy_data( "COPY copytable FROM STDOUT" ) do |res|
 					@conn.put_copy_data "xyz\n"
 				end
-			}.to raise_error(PG::Error, /invalid input syntax for integer/)
+			}.to raise_error(PG::Error, /invalid input syntax for .*integer/)
 		end
 		expect( @conn ).to still_be_usable
 	end
@@ -734,7 +769,7 @@ describe PG::Connection do
 	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( ['5432', '54321'] ).to include( described_class.conndefaults_hash[:port] )
+		expect( ['5432', '54321', @port.to_s] ).to include( described_class.conndefaults_hash[:port] )
 		expect( @conn.conndefaults_hash ).to eq( described_class.conndefaults_hash )
 	end
 
@@ -867,7 +902,7 @@ describe PG::Connection do
 	end
 
 
-	it "handles server close while asynchronous connect", :socket_io do
+	it "handles server close while asynchronous connect" do
 		serv = TCPServer.new( '127.0.0.1', 54320 )
 		conn = described_class.connect_start( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
 		expect( [PG::PGRES_POLLING_WRITING, PG::CONNECTION_OK] ).to include conn.connect_poll
@@ -914,7 +949,21 @@ describe PG::Connection do
 		expect { conn.finish }.to raise_error( PG::ConnectionBad, /connection is closed/i )
 	end
 
-	it "closes the IO fetched from #socket_io when the connection is closed", :without_transaction, :socket_io do
+	it "can use conn.reset to restart the connection" do
+		ios = IO.pipe
+		conn = PG.connect( @conninfo )
+
+		# Close the two pipe file descriptors, so that the file descriptor of
+		# newly established connection is probably distinct from the previous one.
+		ios.each(&:close)
+		conn.reset
+
+		# The new connection should work even when the file descriptor has changed.
+		expect( conn.exec("SELECT 1").values ).to eq([["1"]])
+		conn.close
+	end
+
+	it "closes the IO fetched from #socket_io when the connection is closed", :without_transaction do
 		conn = PG.connect( @conninfo )
 		io = conn.socket_io
 		conn.finish
@@ -922,7 +971,7 @@ describe PG::Connection do
 		expect { conn.socket_io }.to raise_error( PG::ConnectionBad, /connection is closed/i )
 	end
 
-	it "closes the IO fetched from #socket_io when the connection is reset", :without_transaction, :socket_io do
+	it "closes the IO fetched from #socket_io when the connection is reset", :without_transaction do
 		conn = PG.connect( @conninfo )
 		io = conn.socket_io
 		conn.reset
@@ -939,7 +988,7 @@ describe PG::Connection do
 		end
 		serv.close
 		expect{ conn.block }.to raise_error(PG::ConnectionBad, /server closed the connection unexpectedly/)
-		expect{ conn.block }.to raise_error(PG::ConnectionBad, /connection not open/)
+		expect{ conn.block }.to raise_error(PG::ConnectionBad, /can't get socket descriptor/)
 	end
 
 	it "sets the fallback_application_name on new connections" do
@@ -1110,8 +1159,16 @@ describe PG::Connection do
 			expect( ping ).to eq( PG::PQPING_NO_RESPONSE )
 		end
 
-		it "returns correct response when ping connection arguments are wrong" do
+		it "returns error when ping connection arguments are wrong" do
 			ping = described_class.ping('localhost', 'localhost', nil, nil, :test, nil, nil)
+			expect( ping ).to_not eq( PG::PQPING_OK )
+		end
+
+		it "returns correct response when ping connection arguments are wrong" do
+			ping = described_class.ping(
+				:host => 'localhost',
+				:invalid_option => 9999,
+				:dbname => :test)
 			expect( ping ).to eq( PG::PQPING_NO_ATTEMPT )
 		end
 
@@ -1180,53 +1237,41 @@ describe PG::Connection do
 
 	end
 
-	context "multinationalization support", :ruby_19 do
+	context "multinationalization support" do
 
 		describe "rubyforge #22925: m17n support" do
 			it "should return results in the same encoding as the client (iso-8859-1)" do
-				out_string = nil
-				@conn.transaction do |conn|
-					conn.internal_encoding = 'iso8859-1'
-					res = conn.exec_params("VALUES ('fantasia')", [], 0)
-					out_string = res[0]['column1']
-				end
+				@conn.internal_encoding = 'iso8859-1'
+				res = @conn.exec_params("VALUES ('fantasia')", [], 0)
+				out_string = res[0]['column1']
 				expect( out_string ).to eq( 'fantasia' )
 				expect( out_string.encoding ).to eq( Encoding::ISO8859_1 )
 			end
 
 			it "should return results in the same encoding as the client (utf-8)" do
-				out_string = nil
-				@conn.transaction do |conn|
-					conn.internal_encoding = 'utf-8'
-					res = conn.exec_params("VALUES ('世界線航跡蔵')", [], 0)
-					out_string = res[0]['column1']
-				end
+				@conn.internal_encoding = 'utf-8'
+				res = @conn.exec_params("VALUES ('世界線航跡蔵')", [], 0)
+				out_string = res[0]['column1']
 				expect( out_string ).to eq( '世界線航跡蔵' )
 				expect( out_string.encoding ).to eq( Encoding::UTF_8 )
 			end
 
 			it "should return results in the same encoding as the client (EUC-JP)" do
-				out_string = nil
-				@conn.transaction do |conn|
-					conn.internal_encoding = 'EUC-JP'
-					stmt = "VALUES ('世界線航跡蔵')".encode('EUC-JP')
-					res = conn.exec_params(stmt, [], 0)
-					out_string = res[0]['column1']
-				end
+				@conn.internal_encoding = 'EUC-JP'
+				stmt = "VALUES ('世界線航跡蔵')".encode('EUC-JP')
+				res = @conn.exec_params(stmt, [], 0)
+				out_string = res[0]['column1']
 				expect( out_string ).to eq( '世界線航跡蔵'.encode('EUC-JP') )
 				expect( out_string.encoding ).to eq( Encoding::EUC_JP )
 			end
 
 			it "returns the results in the correct encoding even if the client_encoding has " +
 			   "changed since the results were fetched" do
-				out_string = nil
-				@conn.transaction do |conn|
-					conn.internal_encoding = 'EUC-JP'
-					stmt = "VALUES ('世界線航跡蔵')".encode('EUC-JP')
-					res = conn.exec_params(stmt, [], 0)
-					conn.internal_encoding = 'utf-8'
-					out_string = res[0]['column1']
-				end
+				@conn.internal_encoding = 'EUC-JP'
+				stmt = "VALUES ('世界線航跡蔵')".encode('EUC-JP')
+				res = @conn.exec_params(stmt, [], 0)
+				@conn.internal_encoding = 'utf-8'
+				out_string = res[0]['column1']
 				expect( out_string ).to eq( '世界線航跡蔵'.encode('EUC-JP') )
 				expect( out_string.encoding ).to eq( Encoding::EUC_JP )
 			end
@@ -1236,6 +1281,22 @@ describe PG::Connection do
 				expect( @conn.internal_encoding ).to eq( Encoding::ASCII_8BIT )
 			end
 
+			it "the connection should use JOHAB dummy encoding when it's set to JOHAB" do
+				@conn.set_client_encoding "JOHAB"
+				val = @conn.exec("SELECT chr(x'3391'::int)").values[0][0]
+				expect( val.encoding.name ).to eq( "JOHAB" )
+				expect( val.unpack("H*")[0] ).to eq( "dc65" )
+			end
+
+			it "can retrieve server encoding as text" do
+				enc = @conn.parameter_status "server_encoding"
+				expect( enc ).to eq( "UTF8" )
+			end
+
+			it "can retrieve server encoding as ruby encoding" do
+				expect( @conn.external_encoding ).to eq( Encoding::UTF_8 )
+			end
+
 			it "uses the client encoding for escaped string" do
 				original = "Möhre to 'scape".encode( "utf-16be" )
 				@conn.set_client_encoding( "euc_jp" )
@@ -1289,6 +1350,21 @@ describe PG::Connection do
 				expect { @conn.set_client_encoding( :invalid ) }.to raise_error(TypeError)
 				expect { @conn.set_client_encoding( nil ) }.to raise_error(TypeError)
 			end
+
+			it "can use an encoding with high index for client encoding" do
+				# Allocate a lot of encoding indices, so that MRI's ENCODING_INLINE_MAX is exceeded
+				unless Encoding.name_list.include?("pgtest-0")
+					256.times do |eidx|
+						Encoding::UTF_8.replicate("pgtest-#{eidx}")
+					end
+				end
+
+				# Now allocate the JOHAB encoding with an unusual high index
+				@conn.set_client_encoding "JOHAB"
+				val = @conn.exec("SELECT chr(x'3391'::int)").values[0][0]
+				expect( val.encoding.name ).to eq( "JOHAB" )
+			end
+
 		end
 
 		describe "respect and convert character encoding of input strings" do
@@ -1432,7 +1508,7 @@ describe PG::Connection do
 
 		describe "Ruby 1.9.x default_internal encoding" do
 
-			it "honors the Encoding.default_internal if it's set and the synchronous interface is used" do
+			it "honors the Encoding.default_internal if it's set and the synchronous interface is used", :without_transaction do
 				@conn.transaction do |txn_conn|
 					txn_conn.internal_encoding = Encoding::ISO8859_1
 					txn_conn.exec( "CREATE TABLE defaultinternaltest ( foo text )" )
@@ -1534,9 +1610,8 @@ describe PG::Connection do
 			end
 		end
 
-		it "receives properly encoded text from wait_for_notify" do
+		it "receives properly encoded text from wait_for_notify", :without_transaction do
 			@conn.internal_encoding = 'utf-8'
-			@conn.exec( 'ROLLBACK' )
 			@conn.exec( 'LISTEN "Möhre"' )
 			@conn.exec( %Q{NOTIFY "Möhre", '世界線航跡蔵'} )
 			event, pid, msg = nil
@@ -1547,13 +1622,13 @@ describe PG::Connection do
 
 			expect( event ).to eq( "Möhre" )
 			expect( event.encoding ).to eq( Encoding::UTF_8 )
+			expect( pid ).to be_a_kind_of(Integer)
 			expect( msg ).to eq( '世界線航跡蔵' )
 			expect( msg.encoding ).to eq( Encoding::UTF_8 )
 		end
 
-		it "returns properly encoded text from notifies" do
+		it "returns properly encoded text from notifies", :without_transaction do
 			@conn.internal_encoding = 'utf-8'
-			@conn.exec( 'ROLLBACK' )
 			@conn.exec( 'LISTEN "Möhre"' )
 			@conn.exec( %Q{NOTIFY "Möhre", '世界線航跡蔵'} )
 			@conn.exec( 'UNLISTEN "Möhre"' )
@@ -1567,7 +1642,7 @@ describe PG::Connection do
 		end
 	end
 
-	context "OS thread support", :ruby_19 do
+	context "OS thread support" do
 		it "Connection#exec shouldn't block a second thread" do
 			t = Thread.new do
 				@conn.exec( "select pg_sleep(1)" )
@@ -1628,12 +1703,12 @@ describe PG::Connection do
 			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.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.copy_data( "COPY copytable FROM STDOUT", row_encoder ) do |res|
 				@conn.put_copy_data [3]
 				@conn.put_copy_data ["4"]
 			end
@@ -1683,7 +1758,7 @@ describe PG::Connection do
 
 			it "can process #copy_data input queries with row encoder and respects character encoding" do
 				@conn2.exec( "CREATE TEMP TABLE copytable (col1 TEXT)" )
-				res2 = @conn2.copy_data( "COPY copytable FROM STDOUT" ) do |res|
+				@conn2.copy_data( "COPY copytable FROM STDOUT" ) do |res|
 					@conn2.put_copy_data [1]
 					@conn2.put_copy_data ["Möhre".encode("utf-16le")]
 				end
@@ -1734,7 +1809,7 @@ describe PG::Connection do
 			it "can process #copy_data output with row decoder and respects character encoding" do
 				@conn2.internal_encoding = Encoding::ISO8859_1
 				rows = []
-				res2 = @conn2.copy_data( "COPY (VALUES('1'), ('Möhre')) TO STDOUT".encode("utf-16le") ) do |res|
+				@conn2.copy_data( "COPY (VALUES('1'), ('Möhre')) TO STDOUT".encode("utf-16le") ) do |res|
 					while row=@conn2.get_copy_data
 						rows << row
 					end
@@ -1762,35 +1837,106 @@ describe PG::Connection do
 		end
 	end
 
-	describe "deprecated forms of methods" do
-		it "should forward exec to exec_params" do
-			res = @conn.exec("VALUES($1::INT)", [7]).values
-			expect(res).to eq( [["7"]] )
-			res = @conn.exec("VALUES($1::INT)", [7], 1).values
-			expect(res).to eq( [[[7].pack("N")]] )
-			res = @conn.exec("VALUES(8)", [], 1).values
-			expect(res).to eq( [[[8].pack("N")]] )
-		end
-
-		it "should forward exec_params to exec" do
-			res = @conn.exec_params("VALUES(3); VALUES(4)").values
-			expect(res).to eq( [["4"]] )
-			res = @conn.exec_params("VALUES(3); VALUES(4)", nil).values
-			expect(res).to eq( [["4"]] )
-			res = @conn.exec_params("VALUES(3); VALUES(4)", nil, nil).values
-			expect(res).to eq( [["4"]] )
-			res = @conn.exec_params("VALUES(3); VALUES(4)", nil, 1).values
-			expect(res).to eq( [["4"]] )
-			res = @conn.exec_params("VALUES(3); VALUES(4)", nil, nil, nil).values
-			expect(res).to eq( [["4"]] )
-			expect{
-				@conn.exec_params("VALUES(3); VALUES(4)", nil, nil, nil, nil).values
-			}.to raise_error(ArgumentError)
+	describe :field_name_type do
+		before :each do
+			@conn2 = PG.connect(@conninfo)
+		end
+		after :each do
+			@conn2.close
+		end
+
+		it "uses string field names per default" do
+			expect(@conn2.field_name_type).to eq(:string)
+		end
+
+		it "can set string field names" do
+			@conn2.field_name_type = :string
+			expect(@conn2.field_name_type).to eq(:string)
+			res = @conn2.exec("SELECT 1 as az")
+			expect(res.field_name_type).to eq(:string)
+			expect(res.fields).to eq(["az"])
+		end
+
+		it "can set symbol field names" do
+			@conn2.field_name_type = :symbol
+			expect(@conn2.field_name_type).to eq(:symbol)
+			res = @conn2.exec("SELECT 1 as az")
+			expect(res.field_name_type).to eq(:symbol)
+			expect(res.fields).to eq([:az])
 		end
 
-		it "should forward send_query to send_query_params" do
-			@conn.send_query("VALUES($1)", [5])
-			expect(@conn.get_last_result.values).to eq( [["5"]] )
+		it "can't set invalid values" do
+			expect{ @conn2.field_name_type = :sym }.to raise_error(ArgumentError, /invalid argument :sym/)
+			expect{ @conn2.field_name_type = "symbol" }.to raise_error(ArgumentError, /invalid argument "symbol"/)
+		end
+	end
+
+	describe "deprecated forms of methods" do
+		if PG::VERSION < "2"
+			it "should forward exec to exec_params" do
+				res = @conn.exec("VALUES($1::INT)", [7]).values
+				expect(res).to eq( [["7"]] )
+				res = @conn.exec("VALUES($1::INT)", [7], 1).values
+				expect(res).to eq( [[[7].pack("N")]] )
+				res = @conn.exec("VALUES(8)", [], 1).values
+				expect(res).to eq( [[[8].pack("N")]] )
+			end
+
+			it "should forward exec_params to exec" do
+				res = @conn.exec_params("VALUES(3); VALUES(4)").values
+				expect(res).to eq( [["4"]] )
+				res = @conn.exec_params("VALUES(3); VALUES(4)", nil).values
+				expect(res).to eq( [["4"]] )
+				res = @conn.exec_params("VALUES(3); VALUES(4)", nil, nil).values
+				expect(res).to eq( [["4"]] )
+				res = @conn.exec_params("VALUES(3); VALUES(4)", nil, 1).values
+				expect(res).to eq( [["4"]] )
+				res = @conn.exec_params("VALUES(3); VALUES(4)", nil, nil, nil).values
+				expect(res).to eq( [["4"]] )
+				expect{
+					@conn.exec_params("VALUES(3); VALUES(4)", nil, nil, nil, nil).values
+				}.to raise_error(ArgumentError)
+			end
+
+			it "should forward send_query to send_query_params" do
+				@conn.send_query("VALUES($1)", [5])
+				expect(@conn.get_last_result.values).to eq( [["5"]] )
+			end
+
+			it "should respond_to socket", :unix do
+				expect( @conn.socket ).to eq( @conn.socket_io.fileno )
+			end
+		else
+			# Method forwarding removed by PG::VERSION >= "2"
+			it "shouldn't forward exec to exec_params" do
+				expect do
+					@conn.exec("VALUES($1::INT)", [7])
+				end.to raise_error(ArgumentError)
+			end
+
+			it "shouldn't forward exec_params to exec" do
+				expect do
+					@conn.exec_params("VALUES(3); VALUES(4)")
+				end.to raise_error(ArgumentError)
+			end
+
+			it "shouldn't forward send_query to send_query_params" do
+				expect do
+					@conn.send_query("VALUES($1)", [5])
+				end.to raise_error(ArgumentError)
+			end
+
+			it "shouldn't forward async_exec_params to async_exec" do
+				expect do
+					@conn.async_exec_params("VALUES(1)")
+				end.to raise_error(ArgumentError)
+			end
+
+			it "shouldn't respond_to socket" do
+				expect do
+					@conn.socket
+				end.to raise_error(ArgumentError)
+			end
 		end
 
 		it "shouldn't forward send_query_params to send_query" do