pg 1.1.0 → 1.2.2

data/spec/pg/connection_spec.rb

@@ -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
@@ -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
 
@@ -914,6 +949,20 @@ describe PG::Connection do
 		expect { conn.finish }.to raise_error( PG::ConnectionBad, /connection is closed/i )
 	end
 
+	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, :socket_io do
 		conn = PG.connect( @conninfo )
 		io = conn.socket_io
@@ -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
@@ -1551,9 +1626,8 @@ describe PG::Connection do
 			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 +1641,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)" )
@@ -1762,6 +1836,40 @@ describe PG::Connection do
 		end
 	end
 
+	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 "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
 		it "should forward exec to exec_params" do
 			res = @conn.exec("VALUES($1::INT)", [7]).values

data/spec/pg/result_spec.rb

@@ -4,16 +4,65 @@
 require_relative '../helpers'
 
 require 'pg'
+require 'objspace'
 
 
 describe PG::Result do
 
+	describe :field_name_type do
+		let!(:res) { @conn.exec('SELECT 1 AS a, 2 AS "B"') }
+
+		it "uses string field names per default" do
+			expect(res.field_name_type).to eq(:string)
+		end
+
+		it "can set string field names" do
+			res.field_name_type = :string
+			expect(res.field_name_type).to eq(:string)
+		end
+
+		it "can set symbol field names" do
+			res.field_name_type = :symbol
+			expect(res.field_name_type).to eq(:symbol)
+		end
+
+		it "can set static_symbol field names" do
+			res.field_name_type = :static_symbol
+			expect(res.field_name_type).to eq(:static_symbol)
+		end
+
+		it "can't set symbol field names after #fields" do
+			res.fields
+			expect{ res.field_name_type = :symbol }.to raise_error(ArgumentError, /already materialized/)
+			expect(res.field_name_type).to eq(:string)
+		end
+
+		it "can't set invalid values" do
+			expect{ res.field_name_type = :sym }.to raise_error(ArgumentError, /invalid argument :sym/)
+			expect{ res.field_name_type = "symbol" }.to raise_error(ArgumentError, /invalid argument "symbol"/)
+		end
+	end
+
 	it "acts as an array of hashes" do
 		res = @conn.exec("SELECT 1 AS a, 2 AS b")
 		expect( res[0]['a'] ).to eq( '1' )
 		expect( res[0]['b'] ).to eq( '2' )
 	end
 
+	it "acts as an array of hashes with symbols" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		res.field_name_type = :symbol
+		expect( res[0][:a] ).to eq( '1' )
+		expect( res[0][:b] ).to eq( '2' )
+	end
+
+	it "acts as an array of hashes with static_symbols" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		res.field_name_type = :static_symbol
+		expect( res[0][:a] ).to eq( '1' )
+		expect( res[0][:b] ).to eq( '2' )
+	end
+
 	it "yields a row as an array" do
 		res = @conn.exec("SELECT 1 AS a, 2 AS b")
 		list = []
@@ -25,7 +74,6 @@ describe PG::Result do
 		res = @conn.exec("SELECT 1 AS a, 2 AS b")
 		e = res.each_row
 		expect( e ).to be_a_kind_of(Enumerator)
-		pending "Rubinius doesn't define RETURN_SIZED_ENUMERATOR()" if RUBY_ENGINE=='rbx'
 		expect( e.size ).to eq( 1 )
 		expect( e.to_a ).to eq [['1', '2']]
 	end
@@ -34,12 +82,19 @@ describe PG::Result do
 		res = @conn.exec("SELECT 1 AS a, 2 AS b")
 		e = res.each
 		expect( e ).to be_a_kind_of(Enumerator)
-		pending "Rubinius doesn't define RETURN_SIZED_ENUMERATOR()" if RUBY_ENGINE=='rbx'
 		expect( e.size ).to eq( 1 )
 		expect( e.to_a ).to eq [{'a'=>'1', 'b'=>'2'}]
 	end
 
+	it "yields a row as an Enumerator of hashs with symbols" do
+		res = @conn.exec("SELECT 1 AS a, 2 AS b")
+		res.field_name_type = :symbol
+		expect( res.each.to_a ).to eq [{:a=>'1', :b=>'2'}]
+	end
+
 	context "result streaming in single row mode" do
+		let!(:textdec_int){ PG::TextDecoder::Integer.new name: 'INT4', oid: 23 }
+
 		it "can iterate over all rows as Hash" do
 			@conn.send_query( "SELECT generate_series(2,4) AS a; SELECT 1 AS b, generate_series(5,6) AS c" )
 			@conn.set_single_row_mode
@@ -56,6 +111,31 @@ describe PG::Result do
 			expect( @conn.get_result ).to be_nil
 		end
 
+		it "can iterate over all rows as Hash with symbols and typemap" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result.field_names_as(:symbol)
+			res.type_map = PG::TypeMapByColumn.new [textdec_int]
+			expect(
+				res.stream_each.to_a
+			).to eq(
+				[{:a=>2}, {:a=>3}, {:a=>4}]
+			)
+			expect( @conn.get_result ).to be_nil
+		end
+
+		it "keeps last result on error while iterating stream_each" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result
+			expect do
+				res.stream_each_row do
+					raise ZeroDivisionError
+				end
+			end.to raise_error(ZeroDivisionError)
+			expect( res.values ).to eq([["2"]])
+		end
+
 		it "can iterate over all rows as Array" do
 			@conn.send_query( "SELECT generate_series(2,4) AS a; SELECT 1 AS b, generate_series(5,6) AS c" )
 			@conn.set_single_row_mode
@@ -72,6 +152,18 @@ describe PG::Result do
 			expect( @conn.get_result ).to be_nil
 		end
 
+		it "keeps last result on error while iterating stream_each_row" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result
+			expect do
+				res.stream_each_row do
+					raise ZeroDivisionError
+				end
+			end.to raise_error(ZeroDivisionError)
+			expect( res.values ).to eq([["2"]])
+		end
+
 		it "can iterate over all rows as PG::Tuple" do
 			@conn.send_query( "SELECT generate_series(2,4) AS a; SELECT 1 AS b, generate_series(5,6) AS c" )
 			@conn.set_single_row_mode
@@ -88,6 +180,36 @@ describe PG::Result do
 			expect( @conn.get_result ).to be_nil
 		end
 
+		it "clears result on error while iterating stream_each_tuple" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result
+			expect do
+				res.stream_each_tuple do
+					raise ZeroDivisionError
+				end
+			end.to raise_error(ZeroDivisionError)
+			expect( res.cleared? ).to eq(true)
+		end
+
+		it "should reuse field names in stream_each_tuple" do
+			@conn.send_query( "SELECT generate_series(2,3) AS a" )
+			@conn.set_single_row_mode
+			tuple1, tuple2 = *@conn.get_result.stream_each_tuple.to_a
+			expect( tuple1.keys[0].object_id ).to eq(tuple2.keys[0].object_id)
+		end
+
+		it "can iterate over all rows as PG::Tuple with symbols and typemap" do
+			@conn.send_query( "SELECT generate_series(2,4) AS a" )
+			@conn.set_single_row_mode
+			res = @conn.get_result.field_names_as(:symbol)
+			res.type_map = PG::TypeMapByColumn.new [textdec_int]
+			tuples = res.stream_each_tuple.to_a
+			expect( tuples[0][0] ).to eq( 2 )
+			expect( tuples[1][:a] ).to eq( 3 )
+			expect( @conn.get_result ).to be_nil
+		end
+
 		it "complains when not in single row mode" do
 			@conn.send_query( "SELECT generate_series(2,4)" )
 			expect{
@@ -147,6 +269,17 @@ describe PG::Result do
 		).to match( /^parserOpenTable$|^RangeVarGetRelid$/ )
 	end
 
+	it "encapsulates PG_DIAG_SEVERITY_NONLOCALIZED error in a PG::Error object", :postgresql_96 do
+		result = nil
+		begin
+			@conn.exec( "SELECT * FROM nonexistant_table" )
+		rescue PG::Error => err
+			result = err.result
+		end
+
+		expect( result.error_field(PG::PG_DIAG_SEVERITY_NONLOCALIZED) ).to eq( 'ERROR' )
+	end
+
 	it "encapsulates database object names for integrity constraint violations", :postgresql_93 do
 		@conn.exec( "CREATE TABLE integrity (id SERIAL PRIMARY KEY)" )
 		exception = nil
@@ -174,6 +307,28 @@ describe PG::Result do
 		expect( sqlstate ).to eq( 22012 )
 	end
 
+	it "provides the error message" do
+		@conn.send_query("SELECT xyz")
+		res = @conn.get_result; @conn.get_result
+		expect( res.error_message ).to match(/"xyz"/)
+		expect( res.result_error_message ).to match(/"xyz"/)
+	end
+
+	it "provides a verbose error message", :postgresql_96 do
+		@conn.send_query("SELECT xyz")
+		res = @conn.get_result; @conn.get_result
+		# PQERRORS_TERSE should give a single line result
+		expect( res.verbose_error_message(PG::PQERRORS_TERSE, PG::PQSHOW_CONTEXT_ALWAYS) ).to match(/\A.*\n\z/)
+		# PQERRORS_VERBOSE should give a multi line result
+		expect( res.result_verbose_error_message(PG::PQERRORS_VERBOSE, PG::PQSHOW_CONTEXT_NEVER) ).to match(/\n.*\n/)
+	end
+
+	it "provides a verbose error message with SQLSTATE", :postgresql_12 do
+		@conn.send_query("SELECT xyz")
+		res = @conn.get_result; @conn.get_result
+		expect( res.verbose_error_message(PG::PQERRORS_SQLSTATE, PG::PQSHOW_CONTEXT_NEVER) ).to match(/42703/)
+	end
+
 	it "returns the same bytes in binary format that are sent in binary format" do
 		binary_file = File.join(Dir.pwd, 'spec/data', 'random_binary_data')
 		bytes = File.open(binary_file, 'rb').read
@@ -258,6 +413,32 @@ describe PG::Result do
 		expect( res.values ).to eq( [ ["bar"], ["bar2"] ] )
 	end
 
+	it "can retrieve field names" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		expect(res.fields).to eq(["a", "B"])
+	end
+
+	it "can retrieve field names as symbols" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		res.field_name_type = :symbol
+		expect(res.fields).to eq([:a, :B])
+	end
+
+	it "can retrieve single field names" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		expect(res.fname(0)).to eq("a")
+		expect(res.fname(1)).to eq("B")
+		expect{res.fname(2)}.to raise_error(ArgumentError)
+	end
+
+	it "can retrieve single field names as symbol" do
+		res = @conn.exec('SELECT 1 AS a, 2 AS "B"')
+		res.field_name_type = :symbol
+		expect(res.fname(0)).to eq(:a)
+		expect(res.fname(1)).to eq(:B)
+		expect{res.fname(2)}.to raise_error(ArgumentError)
+	end
+
 	# PQfmod
 	it "can return the type modifier for a result column" do
 		@conn.exec( 'CREATE TABLE fmodtest ( foo varchar(33) )' )
@@ -355,8 +536,9 @@ describe PG::Result do
 		res = @conn.exec( "SELECT 1 AS x, 'a' AS y UNION ALL SELECT 2, 'b'" )
 		expect( res.field_values('x') ).to eq( ['1', '2'] )
 		expect( res.field_values('y') ).to eq( ['a', 'b'] )
+		expect( res.field_values(:x) ).to eq( ['1', '2'] )
 		expect{ res.field_values('') }.to raise_error(IndexError)
-		expect{ res.field_values(:x) }.to raise_error(TypeError)
+		expect{ res.field_values(0) }.to raise_error(TypeError)
 	end
 
 	it "can return the values of a single tuple" do
@@ -444,6 +626,13 @@ describe PG::Result do
 		expect( r.inspect ).to match(/cleared/)
 	end
 
+	it "should give account about memory usage" do
+		r = @conn.exec "select 1"
+		expect( ObjectSpace.memsize_of(r) ).to be > 1000
+		r.clear
+		expect( ObjectSpace.memsize_of(r) ).to be < 100
+	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 }
@@ -470,6 +659,7 @@ describe PG::Result do
 			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] )
+			expect( res.field_values(:f) ).to eq( [123] )
 			expect( res.tuple_values(0) ).to eq( [123] )
 		end