pg 0.18.4 → 0.21.0

data/lib/pg/connection.rb

@@ -110,12 +110,20 @@ class PG::Connection
 	# of #put_copy_data, #get_copy_data and #put_copy_end.
 	#
 	# Example with CSV input format:
-	#   conn.exec "create table my_table (a text,b text,c text,d text,e text)"
+	#   conn.exec "create table my_table (a text,b text,c text,d text)"
 	#   conn.copy_data "COPY my_table FROM STDIN CSV" do
-	#     conn.put_copy_data "some,csv,data,to,copy\n"
-	#     conn.put_copy_data "more,csv,data,to,copy\n"
+	#     conn.put_copy_data "some,data,to,copy\n"
+	#     conn.put_copy_data "more,data,to,copy\n"
+	#   end
+	# This creates +my_table+ and inserts two CSV rows.
+	#
+	# The same with text format encoder PG::TextEncoder::CopyRow
+	# and Array input:
+	#   enco = PG::TextEncoder::CopyRow.new
+	#   conn.copy_data "COPY my_table FROM STDIN", enco do
+	#     conn.put_copy_data ['some', 'data', 'to', 'copy']
+	#     conn.put_copy_data ['more', 'data', 'to', 'copy']
 	#   end
-	# This creates +my_table+ and inserts two rows.
 	#
 	# Example with CSV output format:
 	#   conn.copy_data "COPY my_table TO STDOUT CSV" do
@@ -124,8 +132,21 @@ class PG::Connection
 	#     end
 	#   end
 	# This prints all rows of +my_table+ to stdout:
-	#   "some,csv,data,to,copy\n"
-	#   "more,csv,data,to,copy\n"
+	#   "some,data,to,copy\n"
+	#   "more,data,to,copy\n"
+	#
+	# The same with text format decoder PG::TextDecoder::CopyRow
+	# and Array output:
+	#   deco = PG::TextDecoder::CopyRow.new
+	#   conn.copy_data "COPY my_table TO STDOUT", deco do
+	#     while row=conn.get_copy_data
+	#       p row
+	#     end
+	#   end
+	# This receives all rows of +my_table+ as ruby array:
+	#   ["some", "data", "to", "copy"]
+	#   ["more", "data", "to", "copy"]
+
 	def copy_data( sql, coder=nil )
 		res = exec( sql )
 
@@ -165,7 +186,7 @@ class PG::Connection
 				raise
 			else
 				res = get_last_result
-				if res.result_status != PGRES_COMMAND_OK
+				if !res || res.result_status != PGRES_COMMAND_OK
 					while get_copy_data
 					end
 					while get_result
@@ -224,8 +245,23 @@ class PG::Connection
 		end
 	end
 
-end # class PG::Connection
+	# Method 'ssl_attribute' was introduced in PostgreSQL 9.5.
+	if self.instance_methods.find{|m| m.to_sym == :ssl_attribute }
+		# call-seq:
+		#   conn.ssl_attributes -> Hash<String,String>
+		#
+		# Returns SSL-related information about the connection as key/value pairs
+		#
+		# The available attributes varies depending on the SSL library being used,
+		# and the type of connection.
+		#
+		# See also #ssl_attribute
+		def ssl_attributes
+			ssl_attribute_names.each.with_object({}) do |n,h|
+				h[n] = ssl_attribute(n)
+			end
+		end
+	end
 
-# Backward-compatible alias
-PGconn = PG::Connection
+end # class PG::Connection
 

data/lib/pg/deprecated_constants.rb

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+# Warn about use of deprecated constants when this is autoloaded
+callsite = caller(3).first
+
+warn <<END_OF_WARNING
+The PGconn, PGresult, and PGError constants are deprecated, and will be
+removed as of version 1.0.
+
+You should use PG::Connection, PG::Result, and PG::Error instead, respectively.
+
+Called from #{callsite}
+END_OF_WARNING
+
+
+
+PGconn   = PG::Connection
+PGresult = PG::Result
+PGError  = PG::Error
+

data/lib/pg/result.rb

@@ -12,15 +12,20 @@ class PG::Result
 	# See PG::BasicTypeMapForResults
 	def map_types!(type_map)
 		self.type_map = type_map
-		self
+		return self
 	end
 
+
+	### Return a String representation of the object suitable for debugging.
 	def inspect
 		str = self.to_s
-		str[-1,0] = " status=#{res_status(result_status)} ntuples=#{ntuples} nfields=#{nfields} cmd_tuples=#{cmd_tuples}"
-		str
+		str[-1,0] = if cleared?
+			" cleared"
+		else
+			" status=#{res_status(result_status)} ntuples=#{ntuples} nfields=#{nfields} cmd_tuples=#{cmd_tuples}"
+		end
+		return str
 	end
+
 end # class PG::Result
 
-# Backward-compatible alias
-PGresult = PG::Result

data/lib/pg/text_decoder.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'date'
+require 'json'
 
 module PG
 	module TextDecoder
@@ -39,6 +40,12 @@ module PG
 				end
 			end
 		end
+
+		class JSON < SimpleDecoder
+			def decode(string, tuple=nil, field=nil)
+				::JSON.parse(string, quirks_mode: true)
+			end
+		end
 	end
 end # module PG
 

data/lib/pg/text_encoder.rb

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+require 'json'
+
 module PG
 	module TextEncoder
 		class Date < SimpleEncoder
@@ -22,6 +24,12 @@ module PG
 				value.respond_to?(:strftime) ? value.strftime(STRFTIME_ISO_DATETIME_WITH_TIMEZONE) : value
 			end
 		end
+
+		class JSON < SimpleEncoder
+			def encode(value)
+				::JSON.generate(value, quirks_mode: true)
+			end
+		end
 	end
 end # module PG
 

data/lib/pg.rb

@@ -8,11 +8,22 @@ rescue LoadError
 		major_minor = RUBY_VERSION[ /^(\d+\.\d+)/ ] or
 			raise "Oops, can't extract the major/minor version from #{RUBY_VERSION.dump}"
 
-		# Set the PATH environment variable, so that libpq.dll can be found.
-		old_path = ENV['PATH']
-		ENV['PATH'] = "#{File.expand_path("../#{RUBY_PLATFORM}", __FILE__)};#{old_path}"
-		require "#{major_minor}/pg_ext"
-		ENV['PATH'] = old_path
+		add_dll_path = proc do |path, &block|
+			begin
+				require 'ruby_installer/runtime'
+				RubyInstaller::Runtime.add_dll_directory(path, &block)
+			rescue LoadError
+				old_path = ENV['PATH']
+				ENV['PATH'] = "#{path};#{old_path}"
+				block.call
+				ENV['PATH'] = old_path
+			end
+		end
+
+		# Temporary add this directory for DLL search, so that libpq.dll can be found.
+		add_dll_path.call(__dir__) do
+			require "#{major_minor}/pg_ext"
+		end
 	else
 		raise
 	end
@@ -24,10 +35,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.18.4'
+	VERSION = '0.21.0'
 
 	# VCS revision
-	REVISION = %q$Revision: da42b972b5ab $
+	REVISION = %q$Revision: f6063a34ae2b $
 
 	class NotAllCopyDataRetrieved < PG::Error
 	end
@@ -59,6 +70,7 @@ module PG
 end # module PG
 
 
-# Backward-compatible aliase
-PGError = PG::Error
+autoload :PGError,  'pg/deprecated_constants'
+autoload :PGconn,   'pg/deprecated_constants'
+autoload :PGresult, 'pg/deprecated_constants'
 

data/spec/helpers.rb

@@ -339,17 +339,14 @@ RSpec.configure do |config|
 	config.filter_run_excluding :socket_io unless
 		PG::Connection.instance_methods.map( &:to_sym ).include?( :socket_io )
 
-	config.filter_run_excluding :postgresql_90 unless
-		PG::Connection.instance_methods.map( &:to_sym ).include?( :escape_literal )
-
-	if !PG.respond_to?( :library_version )
-		config.filter_run_excluding( :postgresql_91, :postgresql_92, :postgresql_93, :postgresql_94 )
-	elsif PG.library_version < 90200
-		config.filter_run_excluding( :postgresql_92, :postgresql_93, :postgresql_94 )
+	if PG.library_version < 90200
+		config.filter_run_excluding( :postgresql_92, :postgresql_93, :postgresql_94, :postgresql_95 )
 	elsif PG.library_version < 90300
-		config.filter_run_excluding( :postgresql_93, :postgresql_94 )
+		config.filter_run_excluding( :postgresql_93, :postgresql_94, :postgresql_95 )
 	elsif PG.library_version < 90400
-		config.filter_run_excluding( :postgresql_94 )
+		config.filter_run_excluding( :postgresql_94, :postgresql_95 )
+	elsif PG.library_version < 90500
+		config.filter_run_excluding( :postgresql_95 )
 	end
 end
 

data/spec/pg/basic_type_mapping_spec.rb

@@ -166,6 +166,27 @@ describe 'Basic type mapping' do
 				end
 			end
 
+			it "should do JSON conversions", :postgresql_94 do
+				[0].each do |format|
+					['JSON', 'JSONB'].each do |type|
+						res = @conn.exec( "SELECT CAST('123' AS #{type}),
+																			CAST('12.3' AS #{type}),
+																			CAST('true' AS #{type}),
+																			CAST('false' AS #{type}),
+																			CAST('null' AS #{type}),
+																			CAST('[1, \"a\", null]' AS #{type}),
+																			CAST('{\"b\" : [2,3]}' AS #{type})", [], format )
+						expect( res.getvalue(0,0) ).to eq( 123 )
+						expect( res.getvalue(0,1) ).to be_within(0.1).of( 12.3 )
+						expect( res.getvalue(0,2) ).to eq( true )
+						expect( res.getvalue(0,3) ).to eq( false )
+						expect( res.getvalue(0,4) ).to eq( nil )
+						expect( res.getvalue(0,5) ).to eq( [1, "a", nil] )
+						expect( res.getvalue(0,6) ).to eq( {"b" => [2, 3]} )
+					end
+				end
+			end
+
 			it "should do array type conversions" do
 				[0].each do |format|
 					res = @conn.exec( "SELECT CAST('{1,2,3}' AS INT2[]), CAST('{{1,2},{3,4}}' AS INT2[][]),
@@ -228,6 +249,39 @@ describe 'Basic type mapping' do
 				res = @conn.exec( "SELECT * FROM copytable" )
 				expect( res.values ).to eq( [['a', '123', '{5,4,3}'], ['b', '234', '{2,3}']] )
 			end
+
+			it "can do JSON conversions", :postgresql_94 do
+				['JSON', 'JSONB'].each do |type|
+					sql = "SELECT CAST('123' AS #{type}),
+						CAST('12.3' AS #{type}),
+						CAST('true' AS #{type}),
+						CAST('false' AS #{type}),
+						CAST('null' AS #{type}),
+						CAST('[1, \"a\", null]' AS #{type}),
+						CAST('{\"b\" : [2,3]}' AS #{type})"
+
+					tm = basic_type_mapping.build_column_map( @conn.exec( sql ) )
+					expect( tm.coders.map(&:name) ).to eq( [type.downcase] * 7 )
+
+					res = @conn.exec_params( "SELECT $1, $2, $3, $4, $5, $6, $7",
+						[ 123,
+							12.3,
+							true,
+							false,
+							nil,
+							[1, "a", nil],
+							{"b" => [2, 3]},
+						], 0, tm )
+
+					expect( res.getvalue(0,0) ).to eq( "123" )
+					expect( res.getvalue(0,1) ).to eq( "12.3" )
+					expect( res.getvalue(0,2) ).to eq( "true" )
+					expect( res.getvalue(0,3) ).to eq( "false" )
+					expect( res.getvalue(0,4) ).to eq( nil )
+					expect( res.getvalue(0,5).gsub(" ","") ).to eq( "[1,\"a\",null]" )
+					expect( res.getvalue(0,6).gsub(" ","") ).to eq( "{\"b\":[2,3]}" )
+				end
+			end
 		end
 
 		context "with usage of result oids for copy encoder selection" do

data/spec/pg/connection_spec.rb

@@ -643,6 +643,31 @@ describe PG::Connection do
 		expect( @conn ).to still_be_usable
 	end
 
+	it "gracefully handle SQL statements while in #copy_data for input" do
+		@conn.exec "ROLLBACK"
+		@conn.transaction do
+			@conn.exec( "CREATE TEMP TABLE copytable (col1 INT)" )
+			expect {
+				@conn.copy_data( "COPY copytable FROM STDOUT" ) do |res|
+					@conn.exec "SELECT 1"
+				end
+			}.to raise_error(PG::Error, /no COPY in progress/)
+		end
+		expect( @conn ).to still_be_usable
+	end
+
+	it "gracefully handle SQL statements while in #copy_data for output" do
+		@conn.exec "ROLLBACK"
+		@conn.transaction do
+			expect {
+				@conn.copy_data( "COPY (VALUES(1), (2)) TO STDOUT" ) do |res|
+					@conn.exec "SELECT 3"
+				end
+			}.to raise_error(PG::Error, /no COPY in progress/)
+		end
+		expect( @conn ).to still_be_usable
+	end
+
 	it "should raise an error for non copy statements in #copy_data" do
 		expect {
 			@conn.copy_data( "SELECT 1" ){}
@@ -684,13 +709,13 @@ describe PG::Connection do
 	end
 
 	it "described_class#block should allow a timeout" do
-		@conn.send_query( "select pg_sleep(3)" )
+		@conn.send_query( "select pg_sleep(1)" )
 
 		start = Time.now
-		@conn.block( 0.1 )
+		@conn.block( 0.3 )
 		finish = Time.now
 
-		expect( (finish - start) ).to be_within( 0.05 ).of( 0.1 )
+		expect( (finish - start) ).to be_within( 0.2 ).of( 0.3 )
 	end
 
 
@@ -725,6 +750,25 @@ describe PG::Connection do
 		expect( @conn.conninfo_hash[:dbname] ).to eq( 'test' )
 	end
 
+	describe "connection information related to SSL" do
+
+		it "can retrieve connection's ssl state", :postgresql_95 do
+			expect( @conn.ssl_in_use? ).to be false
+		end
+
+		it "can retrieve connection's ssl attribute_names", :postgresql_95 do
+			expect( @conn.ssl_attribute_names ).to be_a(Array)
+		end
+
+		it "can retrieve a single ssl connection attribute", :postgresql_95 do
+			expect( @conn.ssl_attribute('dbname') ).to eq( nil )
+		end
+
+		it "can retrieve all connection's ssl attributes", :postgresql_95 do
+			expect( @conn.ssl_attributes ).to be_a_kind_of( Hash )
+		end
+	end
+
 
 	it "honors the connect_timeout connection parameter", :postgresql_93 do
 		conn = PG.connect( port: @port, dbname: 'test', connect_timeout: 11 )
@@ -1070,8 +1114,8 @@ describe PG::Connection do
 					res.check
 					first_row_time = Time.now unless first_row_time
 				end
-				expect( (Time.now - start_time) ).to be >= 1.0
-				expect( (first_row_time - start_time) ).to be < 1.0
+				expect( (Time.now - start_time) ).to be >= 0.9
+				expect( (first_row_time - start_time) ).to be < 0.9
 			end
 
 			it "should receive rows before entire query fails" do
@@ -1150,51 +1194,137 @@ describe PG::Connection do
 			end
 
 			it "uses the client encoding for escaped string" do
-				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				original = "Möhre to\0 escape".encode( "utf-16be" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = @conn.escape( original )
 				expect( escaped.encoding ).to eq( Encoding::EUC_JP )
-				expect( escaped ).to eq( "string to" )
+				expect( escaped ).to eq( "Möhre to".encode(Encoding::EUC_JP) )
 			end
 
 			it "uses the client encoding for escaped literal", :postgresql_90 do
-				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				original = "Möhre to\0 escape".encode( "utf-16be" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = @conn.escape_literal( original )
 				expect( escaped.encoding ).to eq( Encoding::EUC_JP )
-				expect( escaped ).to eq( "'string to'" )
+				expect( escaped ).to eq( "'Möhre to'".encode(Encoding::EUC_JP) )
 			end
 
 			it "uses the client encoding for escaped identifier", :postgresql_90 do
-				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				original = "Möhre to\0 escape".encode( "utf-16le" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = @conn.escape_identifier( original )
 				expect( escaped.encoding ).to eq( Encoding::EUC_JP )
-				expect( escaped ).to eq( "\"string to\"" )
+				expect( escaped ).to eq( "\"Möhre to\"".encode(Encoding::EUC_JP) )
 			end
 
 			it "uses the client encoding for quote_ident" do
-				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				original = "Möhre to\0 escape".encode( "utf-16le" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = @conn.quote_ident( original )
 				expect( escaped.encoding ).to eq( Encoding::EUC_JP )
-				expect( escaped ).to eq( "\"string to\"" )
+				expect( escaped ).to eq( "\"Möhre to\"".encode(Encoding::EUC_JP) )
 			end
 
 			it "uses the previous string encoding for escaped string" do
-				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				original = "Möhre to\0 escape".encode( "iso-8859-1" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = described_class.escape( original )
 				expect( escaped.encoding ).to eq( Encoding::ISO8859_1 )
-				expect( escaped ).to eq( "string to" )
+				expect( escaped ).to eq( "Möhre to".encode(Encoding::ISO8859_1) )
 			end
 
 			it "uses the previous string encoding for quote_ident" do
-				original = "string to\0 escape".force_encoding( "iso8859-1" )
+				original = "Möhre to\0 escape".encode( "iso-8859-1" )
 				@conn.set_client_encoding( "euc_jp" )
 				escaped  = described_class.quote_ident( original )
 				expect( escaped.encoding ).to eq( Encoding::ISO8859_1 )
-				expect( escaped ).to eq( "\"string to\"" )
+				expect( escaped.encode ).to eq( "\"Möhre to\"".encode(Encoding::ISO8859_1) )
+			end
+		end
+
+		describe "respect and convert character encoding of input strings" do
+			before :each do
+				@conn.internal_encoding = __ENCODING__
+			end
+
+			it "should convert query string and parameters to #exec_params" do
+				r = @conn.exec_params("VALUES( $1, $2, $1=$2, 'grün')".encode("utf-16le"),
+				                  ['grün'.encode('utf-16be'), 'grün'.encode('iso-8859-1')])
+				expect( r.values ).to eq( [['grün', 'grün', 't', 'grün']] )
+			end
+
+			it "should convert query string and parameters to #async_exec" do
+				r = @conn.async_exec("VALUES( $1, $2, $1=$2, 'grün')".encode("cp936"),
+				                  ['grün'.encode('cp850'), 'grün'.encode('utf-16le')])
+				expect( r.values ).to eq( [['grün', 'grün', 't', 'grün']] )
+			end
+
+			it "should convert query string to #exec" do
+				r = @conn.exec("SELECT 'grün'".encode("utf-16be"))
+				expect( r.values ).to eq( [['grün']] )
+			end
+
+			it "should convert query string to #async_exec" do
+				r = @conn.async_exec("SELECT 'grün'".encode("utf-16le"))
+				expect( r.values ).to eq( [['grün']] )
+			end
+
+			it "should convert strings and parameters to #prepare and #exec_prepared" do
+				@conn.prepare("weiß1".encode("utf-16be"), "VALUES( $1, $2, $1=$2, 'grün')".encode("cp850"))
+				r = @conn.exec_prepared("weiß1".encode("utf-32le"),
+				                ['grün'.encode('cp936'), 'grün'.encode('utf-16le')])
+				expect( r.values ).to eq( [['grün', 'grün', 't', 'grün']] )
+			end
+
+			it "should convert strings to #describe_prepared" do
+				@conn.prepare("weiß2", "VALUES(123)")
+				r = @conn.describe_prepared("weiß2".encode("utf-16be"))
+				expect( r.nfields ).to eq( 1 )
+			end
+
+			it "should convert strings to #describe_portal" do
+				@conn.exec "DECLARE cörsör CURSOR FOR VALUES(1,2,3)"
+				r = @conn.describe_portal("cörsör".encode("utf-16le"))
+				expect( r.nfields ).to eq( 3 )
+			end
+
+			it "should convert query string to #send_query" do
+				@conn.send_query("VALUES('grün')".encode("utf-16be"))
+				expect( @conn.get_last_result.values ).to eq( [['grün']] )
+			end
+
+			it "should convert query string and parameters to #send_query" do
+				@conn.send_query("VALUES( $1, $2, $1=$2, 'grün')".encode("utf-16le"),
+				                  ['grün'.encode('utf-32be'), 'grün'.encode('iso-8859-1')])
+				expect( @conn.get_last_result.values ).to eq( [['grün', 'grün', 't', 'grün']] )
+			end
+
+			it "should convert strings and parameters to #send_prepare and #send_query_prepared" do
+				@conn.send_prepare("weiß3".encode("iso-8859-1"), "VALUES( $1, $2, $1=$2, 'grün')".encode("utf-16be"))
+				@conn.get_last_result
+				@conn.send_query_prepared("weiß3".encode("utf-32le"),
+				                ['grün'.encode('utf-16le'), 'grün'.encode('iso-8859-1')])
+				expect( @conn.get_last_result.values ).to eq( [['grün', 'grün', 't', 'grün']] )
+			end
+
+			it "should convert strings to #send_describe_prepared" do
+				@conn.prepare("weiß4", "VALUES(123)")
+				@conn.send_describe_prepared("weiß4".encode("utf-16be"))
+				expect( @conn.get_last_result.nfields ).to eq( 1 )
+			end
+
+			it "should convert strings to #send_describe_portal" do
+				@conn.exec "DECLARE cörsör CURSOR FOR VALUES(1,2,3)"
+				@conn.send_describe_portal("cörsör".encode("utf-16le"))
+				expect( @conn.get_last_result.nfields ).to eq( 3 )
+			end
+
+			it "should convert error string to #put_copy_end" do
+				@conn.exec( "CREATE TEMP TABLE copytable (col1 TEXT)" )
+				@conn.exec( "COPY copytable FROM STDIN" )
+				@conn.put_copy_end("grün".encode("utf-16be"))
+				expect( @conn.get_result.error_message ).to match(/grün/)
+				@conn.get_result
 			end
 		end
 
@@ -1228,12 +1358,12 @@ describe PG::Connection do
 
 				begin
 					prev_encoding = Encoding.default_internal
-					Encoding.default_internal = Encoding::UTF_8
+					Encoding.default_internal = Encoding::ISO8859_2
 
 					conn = PG.connect( @conninfo )
-					expect( conn.internal_encoding ).to eq( Encoding::UTF_8 )
+					expect( conn.internal_encoding ).to eq( Encoding::ISO8859_2 )
 					res = conn.exec( "SELECT foo FROM defaultinternaltest" )
-					expect( res[0]['foo'].encoding ).to eq( Encoding::UTF_8 )
+					expect( res[0]['foo'].encoding ).to eq( Encoding::ISO8859_2 )
 				ensure
 					conn.exec( "DROP TABLE defaultinternaltest" )
 					conn.finish if conn
@@ -1463,15 +1593,15 @@ describe PG::Connection do
 				end
 			end
 
-			it "can process #copy_data input queries with row encoder" 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.put_copy_data [1]
-					@conn2.put_copy_data ["2"]
+					@conn2.put_copy_data ["Möhre".encode("utf-16le")]
 				end
 
 				res = @conn2.exec( "SELECT * FROM copytable ORDER BY col1" )
-				expect( res.values ).to eq( [["1"], ["2"]] )
+				expect( res.values ).to eq( [["1"], ["Möhre"]] )
 			end
 		end
 
@@ -1513,14 +1643,16 @@ describe PG::Connection do
 				end
 			end
 
-			it "can process #copy_data output with row decoder" 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 (SELECT 1 UNION ALL SELECT 2) TO STDOUT" ) do |res|
+				res2 = @conn2.copy_data( "COPY (VALUES('1'), ('Möhre')) TO STDOUT".encode("utf-16le") ) do |res|
 					while row=@conn2.get_copy_data
 						rows << row
 					end
 				end
-				expect( rows ).to eq( [["1"], ["2"]] )
+				expect( rows.last.last.encoding ).to eq( Encoding::ISO8859_1 )
+				expect( rows ).to eq( [["1"], ["Möhre".encode("iso-8859-1")]] )
 			end
 
 			it "can type cast #copy_data output with explicit decoder" do

data/spec/pg/result_spec.rb

@@ -100,11 +100,11 @@ describe PG::Result do
 		expect( res[0]['n'] ).to be_nil()
 	end
 
-	it "encapsulates errors in a PGError object" do
+	it "encapsulates errors in a PG::Error object" do
 		exception = nil
 		begin
 			@conn.exec( "SELECT * FROM nonexistant_table" )
-		rescue PGError => err
+		rescue PG::Error => err
 			exception = err
 		end
 
@@ -136,7 +136,7 @@ describe PG::Result do
 		exception = nil
 		begin
 			@conn.exec( "INSERT INTO integrity VALUES (NULL)" )
-		rescue PGError => err
+		rescue PG::Error => err
 			exception = err
 		end
 		result = exception.result
@@ -152,7 +152,7 @@ describe PG::Result do
 		sqlstate = nil
 		begin
 			res = @conn.exec("SELECT 1/0")
-		rescue PGError => e
+		rescue PG::Error => e
 			sqlstate = e.result.result_error_field( PG::PG_DIAG_SQLSTATE ).to_i
 		end
 		expect( sqlstate ).to eq( 22012 )
@@ -403,6 +403,13 @@ describe PG::Result do
 		expect( r.cleared? ).to eq(true)
 	end
 
+	it "can be inspected before and after clear" do
+		r = @conn.exec "select 1"
+		expect( r.inspect ).to match(/status=PGRES_TUPLES_OK/)
+		r.clear
+		expect( r.inspect ).to match(/cleared/)
+	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 }

data/spec/pg/type_map_by_class_spec.rb

@@ -59,7 +59,7 @@ describe PG::TypeMapByClass do
 	it "should retrieve particular conversions" do
 		expect( tm[Integer] ).to eq(binaryenc_int)
 		expect( tm[Float] ).to eq(textenc_float)
-		expect( tm[Bignum] ).to be_nil
+		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
@@ -102,7 +102,7 @@ describe PG::TypeMapByClass do
 
 	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]']])
+		expect( res.values ).to eq([['5', '1.23', "[:TestSymbol, #{@conn.internal_encoding.inspect}]"]])
 		expect( res.ftype(0) ).to eq(20)
 	end