pg 1.1.4 → 1.2.0

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
 

data/spec/pg/tuple_spec.rb

@@ -8,10 +8,22 @@ require 'objspace'
 describe PG::Tuple do
 	let!(:typemap) { PG::BasicTypeMapForResults.new(@conn) }
 	let!(:result2x2) { @conn.exec( "VALUES(1, 'a'), (2, 'b')" ) }
-	let!(:result2x3cast) { @conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" ).map_types!(typemap) }
+	let!(:result2x2sym) { @conn.exec( "VALUES(1, 'a'), (2, 'b')" ).field_names_as(:symbol) }
+	let!(:result2x3cast) do
+		@conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" )
+			.map_types!(typemap)
+	end
+	let!(:result2x3symcast) do
+		@conn.exec( "SELECT * FROM (VALUES(1, TRUE, '3'), (2, FALSE, '4')) AS m (a, b, b)" )
+			.map_types!(typemap)
+			.field_names_as(:symbol)
+	end
 	let!(:tuple0) { result2x2.tuple(0) }
+	let!(:tuple0sym) { result2x2sym.tuple(0) }
 	let!(:tuple1) { result2x2.tuple(1) }
+	let!(:tuple1sym) { result2x2sym.tuple(1) }
 	let!(:tuple2) { result2x3cast.tuple(0) }
+	let!(:tuple2sym) { result2x3symcast.tuple(0) }
 	let!(:tuple3) { str = Marshal.dump(result2x3cast.tuple(1)); Marshal.load(str) }
 	let!(:tuple_empty) { PG::Tuple.new }
 
@@ -51,9 +63,19 @@ describe PG::Tuple do
 			expect( tuple0["column2"] ).to eq( "a" )
 			expect( tuple2["a"] ).to eq( 1 )
 			expect( tuple2["b"] ).to eq( "3" )
+			expect( tuple0[:b] ).to be_nil
 			expect( tuple0["x"] ).to be_nil
 		end
 
+		it "supports hash like access with symbols" do
+			expect( tuple0sym[:column1] ).to eq( "1" )
+			expect( tuple0sym[:column2] ).to eq( "a" )
+			expect( tuple2sym[:a] ).to eq( 1 )
+			expect( tuple2sym[:b] ).to eq( "3" )
+			expect( tuple2sym["b"] ).to be_nil
+			expect( tuple0sym[:x] ).to be_nil
+		end
+
 		it "casts lazy and caches result" do
 			a = []
 			deco = Class.new(PG::SimpleDecoder) do
@@ -138,6 +160,12 @@ describe PG::Tuple do
 			expect{ tuple_empty.each }.to raise_error(TypeError)
 		end
 
+		it "can be used as an enumerator with symbols" do
+			expect( tuple0sym.each ).to be_kind_of(Enumerator)
+			expect( tuple0sym.each.to_a ).to eq( [[:column1, "1"], [:column2, "a"]] )
+			expect( tuple2sym.each.to_a ).to eq( [[:a, 1], [:b, true], [:b, "3"]] )
+		end
+
 		it "can be used with block" do
 			a = []
 			tuple0.each do |*v|
@@ -174,16 +202,30 @@ describe PG::Tuple do
 
 	it "responds to key?" do
 		expect( tuple1.key?("column1") ).to eq( true )
+		expect( tuple1.key?(:column1) ).to eq( false )
 		expect( tuple1.key?("other") ).to eq( false )
 		expect( tuple1.has_key?("column1") ).to eq( true )
 		expect( tuple1.has_key?("other") ).to eq( false )
 	end
 
+	it "responds to key? as symbol" do
+		expect( tuple1sym.key?(:column1) ).to eq( true )
+		expect( tuple1sym.key?("column1") ).to eq( false )
+		expect( tuple1sym.key?(:other) ).to eq( false )
+		expect( tuple1sym.has_key?(:column1) ).to eq( true )
+		expect( tuple1sym.has_key?(:other) ).to eq( false )
+	end
+
 	it "responds to keys" do
 		expect( tuple0.keys ).to eq( ["column1", "column2"] )
 		expect( tuple2.keys ).to eq( ["a", "b", "b"] )
 	end
 
+	it "responds to keys as symbol" do
+		expect( tuple0sym.keys ).to eq( [:column1, :column2] )
+		expect( tuple2sym.keys ).to eq( [:a, :b, :b] )
+	end
+
 	describe "each_key" do
 		it "can be used as an enumerator" do
 			expect( tuple0.each_key ).to be_kind_of(Enumerator)
@@ -208,12 +250,22 @@ describe PG::Tuple do
 
 	it "responds to index" do
 		expect( tuple0.index("column1") ).to eq( 0 )
+		expect( tuple0.index(:column1) ).to eq( nil )
 		expect( tuple0.index("column2") ).to eq( 1 )
 		expect( tuple0.index("x") ).to eq( nil )
 		expect( tuple2.index("a") ).to eq( 0 )
 		expect( tuple2.index("b") ).to eq( 2 )
 	end
 
+	it "responds to index with symbol" do
+		expect( tuple0sym.index(:column1) ).to eq( 0 )
+		expect( tuple0sym.index("column1") ).to eq( nil )
+		expect( tuple0sym.index(:column2) ).to eq( 1 )
+		expect( tuple0sym.index(:x) ).to eq( nil )
+		expect( tuple2sym.index(:a) ).to eq( 0 )
+		expect( tuple2sym.index(:b) ).to eq( 2 )
+	end
+
 	it "can be used as Enumerable" do
 		expect( tuple0.to_a ).to eq( [["column1", "1"], ["column2", "a"]] )
 		expect( tuple1.to_a ).to eq( [["column1", "2"], ["column2", "b"]] )
@@ -222,7 +274,7 @@ describe PG::Tuple do
 	end
 
 	it "can be marshaled" do
-		[tuple0, tuple1, tuple2, tuple3].each do |t1|
+		[tuple0, tuple1, tuple2, tuple3, tuple0sym, tuple2sym].each do |t1|
 			str = Marshal.dump(t1)
 			t2 = Marshal.load(str)
 
@@ -253,6 +305,7 @@ describe PG::Tuple do
 	it "should override #inspect" do
 		expect( tuple1.inspect ).to eq('#<PG::Tuple column1: "2", column2: "b">')
 		expect( tuple2.inspect ).to eq('#<PG::Tuple a: 1, b: true, b: "3">')
+		expect( tuple2sym.inspect ).to eq('#<PG::Tuple a: 1, b: true, b: "3">')
 		expect{ tuple_empty.inspect }.to raise_error(TypeError)
 	end
 

data/spec/pg/type_map_by_column_spec.rb

@@ -38,7 +38,11 @@ describe PG::TypeMapByColumn do
 			pass_through_type,
 			nil
 		] )
-		expect( cm.inspect ).to eq( "#<PG::TypeMapByColumn INT4:0 TEXT:0 FLOAT4:0 pass_through:1 nil>" )
+	end
+
+	it "should respond to inspect" do
+		cm = PG::TypeMapByColumn.new( [textdec_int, textenc_string, textdec_float, pass_through_type, PG::TextEncoder::Float.new, nil] )
+		expect( cm.inspect ).to eq( "#<PG::TypeMapByColumn INT4:TD TEXT:TE FLOAT4:TD pass_through:BD PG::TextEncoder::Float:TE nil>" )
 	end
 
 	it "should retrieve it's oids" do

data/spec/pg/type_spec.rb

@@ -12,6 +12,7 @@ describe "PG::Type derivations" do
 	let!(:textdec_boolean) { PG::TextDecoder::Boolean.new }
 	let!(:textenc_float) { PG::TextEncoder::Float.new }
 	let!(:textdec_float) { PG::TextDecoder::Float.new }
+	let!(:textenc_numeric) { PG::TextEncoder::Numeric.new }
 	let!(:textenc_string) { PG::TextEncoder::String.new }
 	let!(:textdec_string) { PG::TextDecoder::String.new }
 	let!(:textenc_timestamp) { PG::TextEncoder::TimestampWithoutTimeZone.new }
@@ -254,6 +255,11 @@ describe "PG::Type derivations" do
 				expect( textdec_string.decode( nil )).to be_nil
 				expect( textdec_int.decode( nil )).to be_nil
 			end
+
+			it "should be defined on an encoder but not on a decoder instance" do
+				expect( textdec_int.respond_to?(:decode) ).to be_truthy
+				expect( textenc_int.respond_to?(:decode) ).to be_falsey
+			end
 		end
 
 		describe '#encode' do
@@ -304,12 +310,73 @@ describe "PG::Type derivations" do
 				end
 			end
 
+			it "should encode floats" do
+				expect( textenc_float.encode(0) ).to eq( "0.0" )
+				expect( textenc_float.encode(-1) ).to eq( "-1.0" )
+				expect( textenc_float.encode(-1.234567890123456789) ).to eq( "-1.234567890123457" )
+				expect( textenc_float.encode(9) ).to eq( "9.0" )
+				expect( textenc_float.encode(10) ).to eq( "10.0" )
+				expect( textenc_float.encode(-99) ).to eq( "-99.0" )
+				expect( textenc_float.encode(-100) ).to eq( "-100.0" )
+				expect( textenc_float.encode(999) ).to eq( "999.0" )
+				expect( textenc_float.encode(-1000) ).to eq( "-1000.0" )
+				expect( textenc_float.encode(1234.567890123456789) ).to eq( "1234.567890123457" )
+				expect( textenc_float.encode(-9999) ).to eq( "-9999.0" )
+				expect( textenc_float.encode(10000) ).to eq( "10000.0" )
+				expect( textenc_float.encode(99999) ).to eq( "99999.0" )
+				expect( textenc_float.encode(-100000) ).to eq( "-100000.0" )
+				expect( textenc_float.encode(-999999) ).to eq( "-999999.0" )
+				expect( textenc_float.encode(1000000) ).to eq( "1000000.0" )
+				expect( textenc_float.encode(9999999) ).to eq( "9999999.0" )
+				expect( textenc_float.encode(-100000000000000) ).to eq( "-100000000000000.0" )
+				expect( textenc_float.encode(123456789012345) ).to eq( "123456789012345.0" )
+				expect( textenc_float.encode(-999999999999999) ).to eq( "-999999999999999.0" )
+				expect( textenc_float.encode(1000000000000000) ).to eq( "1e15" )
+				expect( textenc_float.encode(-1234567890123456) ).to eq( "-1.234567890123456e15" )
+				expect( textenc_float.encode(9999999999999999) ).to eq( "1e16" )
+
+				expect( textenc_float.encode(-0.0) ).to eq( "0.0" )
+				expect( textenc_float.encode(0.1) ).to eq( "0.1" )
+				expect( textenc_float.encode(0.1234567890123456789) ).to eq( "0.1234567890123457" )
+				expect( textenc_float.encode(-0.9) ).to eq( "-0.9" )
+				expect( textenc_float.encode(-0.01234567890123456789) ).to eq( "-0.01234567890123457" )
+				expect( textenc_float.encode(0.09) ).to eq( "0.09" )
+				expect( textenc_float.encode(0.001234567890123456789) ).to eq( "0.001234567890123457" )
+				expect( textenc_float.encode(-0.009) ).to eq( "-0.009" )
+				expect( textenc_float.encode(-0.0001234567890123456789) ).to eq( "-0.0001234567890123457" )
+				expect( textenc_float.encode(0.0009) ).to eq( "0.0009" )
+				expect( textenc_float.encode(0.00001) ).to eq( "1e-5" )
+				expect( textenc_float.encode(0.00001234567890123456789) ).to eq( "1.234567890123457e-5" )
+				expect( textenc_float.encode(-0.00009) ).to eq( "-9e-5" )
+				expect( textenc_float.encode(-0.11) ).to eq( "-0.11" )
+				expect( textenc_float.encode(10.11) ).to eq( "10.11" )
+				expect( textenc_float.encode(-1.234567890123456789E-280) ).to eq( "-1.234567890123457e-280" )
+				expect( textenc_float.encode(-1.234567890123456789E280) ).to eq( "-1.234567890123457e280" )
+				expect( textenc_float.encode(9876543210987654321E280) ).to eq( "9.87654321098765e298" )
+				expect( textenc_float.encode(9876543210987654321E-400) ).to eq( "0.0" )
+				expect( textenc_float.encode(9876543210987654321E400) ).to eq( "Infinity" )
+			end
+
 			it "should encode special floats equally to Float#to_s" do
 				expect( textenc_float.encode(Float::INFINITY) ).to eq( Float::INFINITY.to_s )
 				expect( textenc_float.encode(-Float::INFINITY) ).to eq( (-Float::INFINITY).to_s )
 				expect( textenc_float.encode(-Float::NAN) ).to eq( Float::NAN.to_s )
 			end
 
+			it "should encode various inputs to numeric format" do
+				expect( textenc_numeric.encode(0) ).to eq( "0" )
+				expect( textenc_numeric.encode(1) ).to eq( "1" )
+				expect( textenc_numeric.encode(-12345678901234567890123) ).to eq( "-12345678901234567890123" )
+				expect( textenc_numeric.encode(0.0) ).to eq( "0.0" )
+				expect( textenc_numeric.encode(1.0) ).to eq( "1.0" )
+				expect( textenc_numeric.encode(-1.23456789012e45) ).to eq( "-1.23456789012e45" )
+				expect( textenc_numeric.encode(Float::NAN) ).to eq( Float::NAN.to_s )
+				expect( textenc_numeric.encode(BigDecimal(0)) ).to eq( "0.0" )
+				expect( textenc_numeric.encode(BigDecimal(1)) ).to eq( "1.0" )
+				expect( textenc_numeric.encode(BigDecimal("-12345678901234567890.1234567")) ).to eq( "-12345678901234567890.1234567" )
+				expect( textenc_numeric.encode(" 123 ") ).to eq( " 123 " )
+			end
+
 			it "encodes binary string to bytea" do
 				expect( textenc_bytea.encode("\x00\x01\x02\x03\xef".b) ).to eq( "\\x00010203ef" )
 			end
@@ -376,6 +443,11 @@ describe "PG::Type derivations" do
 				expect( textenc_string.encode( nil )).to be_nil
 				expect( textenc_int.encode( nil )).to be_nil
 			end
+
+			it "should be defined on a decoder but not on an encoder instance" do
+				expect( textenc_int.respond_to?(:encode) ).to be_truthy
+				expect( textdec_int.respond_to?(:encode) ).to be_falsey
+			end
 		end
 
 		it "should be possible to marshal encoders" do
@@ -392,7 +464,7 @@ describe "PG::Type derivations" do
 
 		it "should respond to to_h" do
 			expect( textenc_int.to_h ).to eq( {
-				name: 'Integer', oid: 23, format: 0
+				name: 'Integer', oid: 23, format: 0, flags: 0
 			} )
 		end
 
@@ -624,7 +696,7 @@ describe "PG::Type derivations" do
 						expect( textenc_int_array.encode(['1',['2'],'3']) ).to eq( %[{1,{2},3}] )
 					end
 					it 'encodes an array of float8 with sub arrays' do
-						expect( textenc_float_array.encode([1000.11,[-0.00221,[3.31,-441]],[nil,6.61],-7.71]) ).to match(Regexp.new(%[^{1.0001*E+*03,{-2.2*E-*03,{3.3*E+*00,-4.4*E+*02}},{NULL,6.6*E+*00},-7.7*E+*00}$].gsub(/([\.\+\{\}\,])/, "\\\\\\1").gsub(/\*/, "\\d*")))
+						expect( textenc_float_array.encode([1000.11,[-0.00000221,[3.31,-441]],[nil,6.61],-7.71]) ).to match(Regexp.new(%[^{1000.1*,{-2.2*e-*6,{3.3*,-441.0}},{NULL,6.6*},-7.7*}$].gsub(/([\.\+\{\}\,])/, "\\\\\\1").gsub(/\*/, "\\d*")))
 					end
 				end
 				context 'two dimensional arrays' do
@@ -712,15 +784,15 @@ describe "PG::Type derivations" do
 				expect( lt.to_h ).to eq( textenc_int_array.to_h )
 			end
 
-			it "should be possible to marshal encoders" do
-				mt = Marshal.dump(textdec_int_array)
+			it "should be possible to marshal decoders" do
+				mt = Marshal.dump(textdec_string_array_raise)
 				lt = Marshal.load(mt)
-				expect( lt.to_h ).to eq( textdec_int_array.to_h )
+				expect( lt.to_h ).to eq( textdec_string_array_raise.to_h )
 			end
 
 			it "should respond to to_h" do
 				expect( textenc_int_array.to_h ).to eq( {
-					name: nil, oid: 0, format: 0,
+					name: nil, oid: 0, format: 0, flags: 0,
 					elements_type: textenc_int, needs_quotation: false, delimiter: ','
 				} )
 			end
@@ -946,4 +1018,106 @@ describe "PG::Type derivations" do
 			end
 		end
 	end
+
+	describe PG::RecordCoder do
+		describe PG::TextEncoder::Record do
+			context "with default typemap" do
+				let!(:encoder) do
+					PG::TextEncoder::Record.new
+				end
+
+				it "should encode different types of Ruby objects" do
+					expect( encoder.encode([:xyz, 123, 2456, 34567, 456789, 5678901, [1,2,3], 12.1, "abcdefg", nil]) ).
+						to eq('("xyz","123","2456","34567","456789","5678901","[1, 2, 3]","12.1","abcdefg",)')
+				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")'.encode(Encoding::ISO_8859_1) )
+				end
+			end
+
+			context "with TypeMapByClass" do
+				let!(:tm) do
+					tm = PG::TypeMapByClass.new
+					tm[Integer] = textenc_int
+					tm[Float] = intenc_incrementer
+					tm[Array] = PG::TextEncoder::Array.new elements_type: textenc_string
+					tm
+				end
+				let!(:encoder) do
+					PG::TextEncoder::Record.new type_map: tm
+				end
+
+				it "should have reasonable default values" do
+					expect( encoder.name ).to be_nil
+				end
+
+				it "copies all attributes with #dup" do
+					encoder.name = "test"
+					encoder.type_map = PG::TypeMapByColumn.new []
+					encoder2 = encoder.dup
+					expect( encoder.object_id ).to_not eq( encoder2.object_id )
+					expect( encoder2.name ).to eq( "test" )
+					expect( encoder2.type_map ).to be_a_kind_of( PG::TypeMapByColumn )
+				end
+
+				describe '#encode' do
+					it "should encode different types of Ruby objects" do
+						expect( encoder.encode([]) ).to eq("()")
+						expect( encoder.encode(["a"]) ).to eq('("a")')
+						expect( encoder.encode([:xyz, 123, 2456, 34567, 456789, 5678901, [1,2,3], 12.1, "abcdefg", nil]) ).
+							to eq('("xyz","123","2456","34567","456789","5678901","{1,2,3}","13 ","abcdefg",)')
+					end
+
+					it "should escape special characters" do
+						expect( encoder.encode([" \"\t\n\\\r"]) ).to eq("(\" \"\"\t\n##\r\")".gsub("#", "\\"))
+					end
+				end
+			end
+		end
+
+		describe PG::TextDecoder::Record do
+			context "with default typemap" do
+				let!(:decoder) do
+					PG::TextDecoder::Record.new
+				end
+
+				describe '#decode' do
+					it "should decode composite text format to array of strings" do
+						expect( decoder.decode('("fuzzy dice",,"",42,)') ).to eq( ["fuzzy dice",nil, "", "42", nil] )
+					end
+
+					it 'should respect input character encoding' do
+						v = decoder.decode("(Héllo)".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
+
+					it 'should raise an error on malformed input' do
+						expect{ decoder.decode('') }.to raise_error(ArgumentError, /"" - Missing left parenthesis/)
+						expect{ decoder.decode('(') }.to raise_error(ArgumentError, /"\(" - Unexpected end of input/)
+						expect{ decoder.decode('(\\') }.to raise_error(ArgumentError, /"\(\\" - Unexpected end of input/)
+						expect{ decoder.decode('()x') }.to raise_error(ArgumentError, /"\(\)x" - Junk after right parenthesis/)
+					end
+				end
+			end
+
+			context "with TypeMapByColumn" do
+				let!(:tm) do
+					PG::TypeMapByColumn.new [textdec_int, textdec_string, intdec_incrementer, nil]
+				end
+				let!(:decoder) do
+					PG::TextDecoder::Record.new type_map: tm
+				end
+
+				describe '#decode' do
+					it "should decode different types of Ruby objects" do
+						expect( decoder.decode("(123,\" #,#\n#\r#\\ \",234,#\x01#\002)".gsub("#", "\\"))).to eq( [123, " ,\n\r\\ ", 235, "\x01\x02"] )
+					end
+				end
+			end
+		end
+	end
 end