pg 0.18.4 → 0.19.0.pre20160409114042

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 )
 
@@ -224,8 +245,27 @@ class PG::Connection
 		end
 	end
 
+	# 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
+
 end # class PG::Connection
 
+# :stopdoc:
 # Backward-compatible alias
 PGconn = PG::Connection
 

data/lib/pg/result.rb

@@ -12,15 +12,19 @@ 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
+		return str
 	end
+
 end # class PG::Result
 
+# :stopdoc:
 # Backward-compatible alias
 PGresult = PG::Result

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/connection_spec.rb

@@ -684,13 +684,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 +725,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 +1089,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 +1169,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
 
@@ -1463,15 +1568,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 +1618,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/type_map_by_class_spec.rb

@@ -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
 

data/spec/pg/type_map_by_mri_type_spec.rb

@@ -116,7 +116,7 @@ describe PG::TypeMapByMriType 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
 

data/spec/pg/type_spec.rb

@@ -39,6 +39,14 @@ describe "PG::Type derivations" do
 		end.new
 	end
 
+	let!(:intenc_incrementer_with_encoding) do
+		Class.new(PG::SimpleEncoder) do
+			def encode(value, encoding)
+				r = (value.to_i + 1).to_s + " #{encoding}"
+				r.encode!(encoding)
+			end
+		end.new
+	end
 	let!(:intenc_incrementer_with_int_result) do
 		Class.new(PG::SimpleEncoder) do
 			def encode(value)
@@ -127,6 +135,13 @@ describe "PG::Type derivations" do
 					expect( quoted_type.decode(%[a.b]) ).to eq( ['a','b'] )
 					expect( quoted_type.decode(%[a]) ).to eq( ['a'] )
 				end
+
+				it 'should split identifier string with correct character encoding' do
+					quoted_type = PG::TextDecoder::Identifier.new
+					v = quoted_type.decode(%[Héllo].encode("iso-8859-1")).first
+					expect( v.encoding ).to eq( Encoding::ISO_8859_1 )
+					expect( v ).to eq( %[Héllo].encode(Encoding::ISO_8859_1) )
+				end
 			end
 
 			it "should raise when decode method is called with wrong args" do
@@ -209,6 +224,13 @@ describe "PG::Type derivations" do
 					expect( quoted_type.encode( nil ) ).to be_nil
 				end
 
+				it 'should quote identifiers with correct character encoding' do
+					quoted_type = PG::TextEncoder::Identifier.new
+					v = quoted_type.encode(['Héllo'], "iso-8859-1")
+					expect( v ).to eq( %["Héllo"].encode(Encoding::ISO_8859_1) )
+					expect( v.encoding ).to eq( Encoding::ISO_8859_1 )
+				end
+
 				it "will raise a TypeError for invalid arguments to quote_ident" do
 					quoted_type = PG::TextEncoder::Identifier.new
 					expect{ quoted_type.encode( [nil] ) }.to raise_error(TypeError)
@@ -220,6 +242,12 @@ describe "PG::Type derivations" do
 				expect( intenc_incrementer.encode(3) ).to eq( "4 " )
 			end
 
+			it "should encode with ruby encoder and given character encoding" do
+				r = intenc_incrementer_with_encoding.encode(3, Encoding::CP850)
+				expect( r ).to eq( "4 CP850" )
+				expect( r.encoding ).to eq( Encoding::CP850 )
+			end
+
 			it "should return when ruby encoder returns non string values" do
 				expect( intenc_incrementer_with_int_result.encode(3) ).to eq( 4 )
 			end
@@ -447,9 +475,18 @@ describe "PG::Type derivations" do
 				end
 
 				context 'array of types with encoder in ruby space' do
-					it 'encodes with quotation' do
+					it 'encodes with quotation and default character encoding' do
+						array_type = PG::TextEncoder::Array.new elements_type: intenc_incrementer, needs_quotation: true
+						r = array_type.encode([3,4])
+						expect( r ).to eq( %[{"4 ","5 "}] )
+						expect( r.encoding ).to eq( Encoding::ASCII_8BIT )
+					end
+
+					it 'encodes with quotation and given character encoding' do
 						array_type = PG::TextEncoder::Array.new elements_type: intenc_incrementer, needs_quotation: true
-						expect( array_type.encode([3,4]) ).to eq( %[{"4 ","5 "}] )
+						r = array_type.encode([3,4], Encoding::CP850)
+						expect( r ).to eq( %[{"4 ","5 "}] )
+						expect( r.encoding ).to eq( Encoding::CP850 )
 					end
 
 					it 'encodes without quotation' do
@@ -457,6 +494,20 @@ describe "PG::Type derivations" do
 						expect( array_type.encode([3,4]) ).to eq( %[{4 ,5 }] )
 					end
 
+					it 'encodes with default character encoding' do
+						array_type = PG::TextEncoder::Array.new elements_type: intenc_incrementer_with_encoding
+						r = array_type.encode([3,4])
+						expect( r ).to eq( %[{"4 ASCII-8BIT","5 ASCII-8BIT"}] )
+						expect( r.encoding ).to eq( Encoding::ASCII_8BIT )
+					end
+
+					it 'encodes with given character encoding' do
+						array_type = PG::TextEncoder::Array.new elements_type: intenc_incrementer_with_encoding
+						r = array_type.encode([3,4], Encoding::CP850)
+						expect( r ).to eq( %[{"4 CP850","5 CP850"}] )
+						expect( r.encoding ).to eq( Encoding::CP850 )
+					end
+
 					it "should raise when ruby encoder returns non string values" do
 						array_type = PG::TextEncoder::Array.new elements_type: intenc_incrementer_with_int_result, needs_quotation: false
 						expect{ array_type.encode([3,4]) }.to raise_error(TypeError)
@@ -473,6 +524,13 @@ describe "PG::Type derivations" do
 						quoted_type = PG::TextEncoder::QuotedLiteral.new elements_type: textenc_string_array
 						expect( quoted_type.encode(["'A\",","\\B'"]) ).to eq( %['{"''A\\",","\\\\B''"}'] )
 					end
+
+					it 'should quote literals with correct character encoding' do
+						quoted_type = PG::TextEncoder::QuotedLiteral.new elements_type: textenc_string_array
+						v = quoted_type.encode(["Héllo"], "iso-8859-1")
+						expect( v.encoding ).to eq( Encoding::ISO_8859_1 )
+						expect( v ).to eq( %['{Héllo}'].encode(Encoding::ISO_8859_1) )
+					end
 				end
 			end
 
@@ -522,9 +580,19 @@ describe "PG::Type derivations" do
 			expect( e.encode("(\xFBm") ).to eq("KPtt")
 		end
 
+		it 'should encode Strings as base64 with correct character encoding' do
+			e = PG::TextEncoder::ToBase64.new
+			v = e.encode("Héllo".encode("utf-16le"), "iso-8859-1")
+			expect( v ).to eq("SOlsbG8=")
+			expect( v.encoding ).to eq(Encoding::ISO_8859_1)
+		end
+
 		it "should encode Strings as base64 in BinaryDecoder" do
 			e = PG::BinaryDecoder::ToBase64.new
 			expect( e.decode("x") ).to eq("eA==")
+			v = e.decode("Héllo".encode("utf-16le"))
+			expect( v ).to eq("SADpAGwAbABvAA==")
+			expect( v.encoding ).to eq(Encoding::ASCII_8BIT)
 		end
 
 		it "should encode Integers as base64" do
@@ -611,6 +679,12 @@ describe "PG::Type derivations" do
 					expect( encoder.encode([:xyz, 123, 2456, 34567, 456789, 5678901, [1,2,3], 12.1, "abcdefg", nil]) ).
 						to eq("xyz\t123\t2456\t34567\t456789\t5678901\t[1, 2, 3]\t12.1\tabcdefg\t\\N\n")
 				end
+
+				it 'should output a string with correct character encoding' do
+					v = encoder.encode(["Héllo"], "iso-8859-1")
+					expect( v.encoding ).to eq( Encoding::ISO_8859_1 )
+					expect( v ).to eq( "Héllo\n".encode(Encoding::ISO_8859_1) )
+				end
 			end
 
 			context "with TypeMapByClass" do
@@ -675,6 +749,12 @@ describe "PG::Type derivations" do
 					it "should decode different types of Ruby objects" do
 						expect( decoder.decode("123\t \0#\t#\n#\r#\\ \t234\t#\x01#\002\n".gsub("#", "\\"))).to eq( ["123", " \0\t\n\r\\ ", "234", "\x01\x02"] )
 					end
+
+					it 'should respect input character encoding' do
+						v = decoder.decode("Héllo\n".encode("iso-8859-1")).first
+						expect( v.encoding ).to eq(Encoding::ISO_8859_1)
+						expect( v ).to eq("Héllo".encode("iso-8859-1"))
+					end
 				end
 			end