pg 1.1.4-x64-mingw32 → 1.2.0-x64-mingw32

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.2.0
 platform: x64-mingw32
 authors:
 - Michael Granger
@@ -11,9 +11,9 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIENDCCApygAwIBAgIBATANBgkqhkiG9w0BAQsFADAiMSAwHgYDVQQDDBdnZWQv
-  REM9RmFlcmllTVVEL0RDPW9yZzAeFw0xODExMjAxODI5NTlaFw0xOTExMjAxODI5
-  NTlaMCIxIDAeBgNVBAMMF2dlZC9EQz1GYWVyaWVNVUQvREM9b3JnMIIBojANBgkq
+  MIID+DCCAmCgAwIBAgIBAjANBgkqhkiG9w0BAQsFADAiMSAwHgYDVQQDDBdnZWQv
+  REM9RmFlcmllTVVEL0RDPW9yZzAeFw0xOTEyMjQyMDE5NTFaFw0yMDEyMjMyMDE5
+  NTFaMCIxIDAeBgNVBAMMF2dlZC9EQz1GYWVyaWVNVUQvREM9b3JnMIIBojANBgkq
   hkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAvyVhkRzvlEs0fe7145BYLfN6njX9ih5H
   L60U0p0euIurpv84op9CNKF9tx+1WKwyQvQP7qFGuZxkSUuWcP/sFhDXL1lWUuIl
   M4uHbGCRmOshDrF4dgnBeOvkHr1fIhPlJm5FO+Vew8tSQmlDsosxLUx+VB7DrVFO
@@ -22,20 +22,19 @@ cert_chain:
   vQ66lts4alKC69TE5cuKasWBm+16A4aEe3XdZBRNmtOu/g81gvwA7fkJHKllJuaI
   dXzdHqq+zbGZVSQ7pRYHYomD0IiDe1DbIouFnPWmagaBnGHwXkDT2bKKP+s2v21m
   ozilJg4aar2okb/RA6VS87o+d7g6LpDDMMQjH4G9OPnJENLdhu8KnPw/ivSVvQw7
-  N2I4L/ZOIe2DIVuYH7aLHfjZDQv/mNgpAgMBAAGjdTBzMAkGA1UdEwQCMAAwCwYD
-  VR0PBAQDAgSwMB0GA1UdDgQWBBRyjf55EbrHagiRLqt5YAd3yb8k4DAcBgNVHREE
-  FTATgRFnZWRARmFlcmllTVVELm9yZzAcBgNVHRIEFTATgRFnZWRARmFlcmllTVVE
-  Lm9yZzANBgkqhkiG9w0BAQsFAAOCAYEAP9Ffkvg4e8CjIWi8SykQ8oJSS8jbmbgF
-  abke3vXWLG6V9kFiObuJd5wZRBluJANu7bEtjgc3fFaGVP2XxVdCpVjNbmMDg4Qp
-  ovvczP53X6pQP2RSZgxF6Lblvy8y11RziUTVRG/Z2aJHsElo6gI7vQznE/OSDrhC
-  gEhr8uaIUt7D+HZWRbU0+MkKPpL5uMqaFuJbqXEvSwPTuUuYkDfNfsjQO7ruWBac
-  bxHCrvpZ6Tijc0nrlyXi6gPOCLeaqhau2xFnlvKgELwsGYSoKBJyDwqtQ5kwrOlU
-  tkSyLrfZ+RZcH535Hyvif7ZxB0v5OxXXoec+N2vrUsEUMRDL9dg4/WFdN8hIOixF
-  3IPKpZ1ho0Ya5q7yhygtBK9/NBFHw+nbJjcltfPDBXleRe8u73gnQo8AZIhStYSP
-  v4qqqa27Bs468d6SoPxjSm8a2mM9HZ4OdWhq4tFsbTeXDVquCfi64OTEaTt2xQdR
-  JnC4lpJfCP6aCXa5h2XAQfPSH636cQap
+  N2I4L/ZOIe2DIVuYH7aLHfjZDQv/mNgpAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYD
+  VR0PBAQDAgSwMB0GA1UdDgQWBBRyjf55EbrHagiRLqt5YAd3yb8k4DANBgkqhkiG
+  9w0BAQsFAAOCAYEAifxlz7x0EfT3fjhM520ZEIrWa+tLMuLKNefkY18u8tZnx4EX
+  Xxwh3tna3fvNfrOrdY5leIj1dbv4FTRg+gIBnIxAySqvpGvI/Axg5EdYbwninCLL
+  LAKCmRo+5QwaPMYN2zdHIjGrp8jg1neCo5zy6tVvyTv0DMI6FLrydVJYduMMDFSy
+  gQKR1rVOcCJtnBnLCF9+kKEUKohAHOmGsE7OBZFnjMIpH5yUDUVJKByv0gIipFt0
+  1T6zff6oVU0w8WBiNKR381+6sF3wIZVnVY0XeJg6hNL+YecE8ILxLhHTmtT/BO0S
+  3xPze9uXDR+iD6HYl8KU5QEg/dXFPhfQb512vVkTJDZvMcwu6PxDUjHFChLjAji/
+  AZXjg1C5E9znTkeUR8ieU9F1MOKoiH57a5lYSTI8Ga8PpsNXTxNeXc16Ob26CqrJ
+  83uuAYSy65yXDGXXPVBeKPVnYrqp91pqpS5Nh7wfuiCrE8lgU8PATh7K4BV1UhAT
+  0MHbAT42wTYkfUj3
   -----END CERTIFICATE-----
-date: 2019-01-09 00:00:00.000000000 Z
+date: 2019-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hoe-mercurial
@@ -155,14 +154,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.17'
+        version: '3.20'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.17'
+        version: '3.20'
 description: |-
   Pg is the Ruby interface to the {PostgreSQL RDBMS}[http://www.postgresql.org/].
 
@@ -207,6 +206,7 @@ extra_rdoc_files:
 - ext/pg_connection.c
 - ext/pg_copy_coder.c
 - ext/pg_errors.c
+- ext/pg_record_coder.c
 - ext/pg_result.c
 - ext/pg_text_decoder.c
 - ext/pg_text_encoder.c
@@ -218,7 +218,7 @@ extra_rdoc_files:
 - ext/pg_type_map_by_mri_type.c
 - ext/pg_type_map_by_oid.c
 - ext/pg_type_map_in_ruby.c
-- ext/util.c
+- ext/pg_util.c
 files:
 - ".gemtest"
 - BSDL
@@ -248,6 +248,7 @@ files:
 - ext/pg_connection.c
 - ext/pg_copy_coder.c
 - ext/pg_errors.c
+- ext/pg_record_coder.c
 - ext/pg_result.c
 - ext/pg_text_decoder.c
 - ext/pg_text_encoder.c
@@ -259,8 +260,8 @@ files:
 - ext/pg_type_map_by_mri_type.c
 - ext/pg_type_map_by_oid.c
 - ext/pg_type_map_in_ruby.c
-- ext/util.c
-- ext/util.h
+- ext/pg_util.c
+- ext/pg_util.h
 - ext/vc/pg.sln
 - ext/vc/pg_18/pg.vcproj
 - ext/vc/pg_19/pg_19.vcproj
@@ -298,10 +299,11 @@ files:
 - spec/pg/type_map_spec.rb
 - spec/pg/type_spec.rb
 - spec/pg_spec.rb
-homepage: https://bitbucket.org/ged/ruby-pg
+homepage: https://github.com/ged/ruby-pg
 licenses:
-- BSD-3-Clause
-metadata: {}
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/ged/ruby-pg
 post_install_message: 
 rdoc_options:
 - "--main"