sequel 3.37.0 → 3.38.0

data/spec/extensions/pg_inet_spec.rb

@@ -4,9 +4,7 @@ describe "pg_inet extension" do
   ipv6_broken = (IPAddr.new('::1'); false) rescue true
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
-    @db.extension(:pg_array)
-    @db.extension(:pg_inet)
+    @db.extension(:pg_array, :pg_inet)
   end
 
   it "should literalize IPAddr v4 instances to strings correctly" do
@@ -31,7 +29,7 @@ describe "pg_inet extension" do
   end
 
   it "should support using IPAddr instances in array types in bound variables" do
-    @db.bound_variable_arg([IPAddr.new('127.0.0.1')].pg_array, nil).should == '{"127.0.0.1/32"}'
+    @db.bound_variable_arg(Sequel.pg_array([IPAddr.new('127.0.0.1')]), nil).should == '{"127.0.0.1/32"}'
   end
 
   it "should parse inet/cidr type from the schema correctly" do

data/spec/extensions/pg_interval_spec.rb

@@ -8,7 +8,6 @@ else
 describe "pg_interval extension" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
     @db.extension(:pg_array, :pg_interval)
   end
 
@@ -37,8 +36,8 @@ describe "pg_interval extension" do
   end
 
   it "should support using ActiveSupport::Duration instances in array types in bound variables" do
-    @db.bound_variable_arg([ActiveSupport::Duration.new(0, [[:seconds, 0]])].pg_array, nil).should == '{"0"}'
-    @db.bound_variable_arg([ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])].pg_array, nil).should == '{"-6 years -4 months -3 days -20 minutes -10.000001 seconds "}'
+    @db.bound_variable_arg(Sequel.pg_array([ActiveSupport::Duration.new(0, [[:seconds, 0]])]), nil).should == '{"0"}'
+    @db.bound_variable_arg(Sequel.pg_array([ActiveSupport::Duration.new(0, [[:seconds, -10.000001], [:minutes, -20], [:days, -3], [:months, -4], [:years, -6]])]), nil).should == '{"-6 years -4 months -3 days -20 minutes -10.000001 seconds "}'
   end
 
   it "should parse interval type from the schema correctly" do

data/spec/extensions/pg_json_spec.rb

@@ -20,7 +20,6 @@ describe "pg_json extension" do
   end
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
     @db.extension(:pg_array, :pg_json)
   end
 
@@ -43,36 +42,39 @@ describe "pg_json extension" do
   end
 
   it "should literalize HStores to strings correctly" do
-    @db.literal([].pg_json).should == "'[]'::json"
-    @db.literal([1, [2], {'a'=>'b'}].pg_json).should == "'[1,[2],{\"a\":\"b\"}]'::json"
-    @db.literal({}.pg_json).should == "'{}'::json"
-    @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
+    @db.literal(Sequel.pg_json([])).should == "'[]'::json"
+    @db.literal(Sequel.pg_json([1, [2], {'a'=>'b'}])).should == "'[1,[2],{\"a\":\"b\"}]'::json"
+    @db.literal(Sequel.pg_json({})).should == "'{}'::json"
+    @db.literal(Sequel.pg_json('a'=>'b')).should == "'{\"a\":\"b\"}'::json"
   end
 
-  it "should have Hash#pg_json method for creating JSONHash instances" do
-    {}.pg_json.should be_a_kind_of(@hc)
+  it "should have Sequel.pg_json return JSONHash and JSONArray as is" do
+    a = Sequel.pg_json({})
+    Sequel.pg_json(a).should equal(a)
+    a = Sequel.pg_json([])
+    Sequel.pg_json(a).should equal(a)
   end
 
-  it "should have Array#pg_json method for creating JSONArray instances" do
-    [].pg_json.should be_a_kind_of(@ac)
+  it "should have Sequel.pg_json raise an Error if called with a non-hash or array" do
+    proc{Sequel.pg_json(:a)}.should raise_error(Sequel::Error)
   end
 
   it "should have JSONHash#to_hash method for getting underlying hash" do
-    {}.pg_json.to_hash.should be_a_kind_of(Hash)
+    Sequel.pg_json({}).to_hash.should be_a_kind_of(Hash)
   end
 
   it "should have JSONArray#to_a method for getting underlying array" do
-    [].pg_json.to_a.should be_a_kind_of(Array)
+    Sequel.pg_json([]).to_a.should be_a_kind_of(Array)
   end
 
   it "should support using JSONHash and JSONArray as bound variables" do
     @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg([1].pg_json, nil).should == '[1]'
-    @db.bound_variable_arg({'a'=>'b'}.pg_json, nil).should == '{"a":"b"}'
+    @db.bound_variable_arg(Sequel.pg_json([1]), nil).should == '[1]'
+    @db.bound_variable_arg(Sequel.pg_json('a'=>'b'), nil).should == '{"a":"b"}'
   end
 
   it "should support using json[] types in bound variables" do
-    @db.bound_variable_arg([[{"a"=>1}].pg_json, {"b"=>[1, 2]}.pg_json].pg_array, nil).should == '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
+    @db.bound_variable_arg(Sequel.pg_array([Sequel.pg_json([{"a"=>1}]), Sequel.pg_json("b"=>[1, 2])]), nil).should == '{"[{\\"a\\":1}]","{\\"b\\":[1,2]}"}'
   end
 
   it "should parse json type from the schema correctly" do
@@ -81,16 +83,16 @@ describe "pg_json extension" do
   end
 
   it "should support typecasting for the json type" do
-    h = {1=>2}.pg_json
-    a = [1].pg_json
+    h = Sequel.pg_json(1=>2)
+    a = Sequel.pg_json([1])
     @db.typecast_value(:json, h).should equal(h)
     @db.typecast_value(:json, h.to_hash).should == h
     @db.typecast_value(:json, h.to_hash).should be_a_kind_of(@hc)
     @db.typecast_value(:json, a).should equal(a)
     @db.typecast_value(:json, a.to_a).should == a
     @db.typecast_value(:json, a.to_a).should be_a_kind_of(@ac)
-    @db.typecast_value(:json, '[]').should == [].pg_json
-    @db.typecast_value(:json, '{"a": "b"}').should == {"a"=>"b"}.pg_json
+    @db.typecast_value(:json, '[]').should == Sequel.pg_json([])
+    @db.typecast_value(:json, '{"a": "b"}').should == Sequel.pg_json("a"=>"b")
     proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
   end

data/spec/extensions/pg_range_ops_spec.rb

@@ -3,21 +3,28 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "Sequel::Postgres::RangeOp" do
   before do
     @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
-    @h = :h.pg_range
+    @h = Sequel.pg_range_op(:h)
   end
 
   it "#pg_range should return self" do
     @h.pg_range.should equal(@h)
   end
 
-  it "#pg_range should return a RangeOp for symbols, literal strings, and expressions" do
-    @ds.literal(:h.pg_range.lower).should == "lower(h)"
+  it "Sequel.pg_range_op should return argument if already a RangeOp" do
+    Sequel.pg_range_op(@h).should equal(@h)
+  end
+
+  it "Sequel.pg_range should return a new RangeOp if not given a range" do
+    @ds.literal(Sequel.pg_range(:h).lower).should == "lower(h)"
+  end
+
+  it "#pg_range should return a RangeOp for literal strings, and expressions" do
     @ds.literal(Sequel.function(:b, :h).pg_range.lower).should == "lower(b(h))"
     @ds.literal(Sequel.lit('h').pg_range.lower).should == "lower(h)"
   end
 
   it "PGRange#op should return a RangeOp" do
-    @ds.literal((1..2).pg_range(:numrange).op.lower).should == "lower('[1,2]'::numrange)"
+    @ds.literal(Sequel.pg_range(1..2, :numrange).op.lower).should == "lower('[1,2]'::numrange)"
   end
 
   it "should define methods for all of the the PostgreSQL range operators" do

data/spec/extensions/pg_range_spec.rb

@@ -1,13 +1,18 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "pg_range extension" do
+  before(:all) do
+    @pg_types = Sequel::Postgres::PG_TYPES.dup
+  end
+  after(:all) do
+    Sequel::Postgres::PG_TYPES.replace(@pg_types)
+  end
+
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     @R = Sequel::Postgres::PGRange
-    @db.extend(Module.new{def get_conversion_procs(conn) {} end; def bound_variable_arg(arg, conn) arg end})
     @db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
-    @db.extension(:pg_array)
-    @db.extension(:pg_range)
+    @db.extension(:pg_array, :pg_range)
   end
 
   it "should literalize Range instances to strings correctly" do
@@ -204,13 +209,13 @@ describe "pg_range extension" do
   end
 
   it "should set appropriate timestamp range conversion procs when getting conversion procs" do
-    procs = @db.send(:get_conversion_procs, nil)
+    procs = @db.conversion_procs
     procs[3908].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').should == (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
     procs[3910].call('[2011-10-20 11:12:13,2011-10-20 11:12:14]').should == (Time.local(2011, 10, 20, 11, 12, 13)..(Time.local(2011, 10, 20, 11, 12, 14)))
   end
 
   it "should set appropriate timestamp range array conversion procs when getting conversion procs" do
-    procs = @db.send(:get_conversion_procs, nil)
+    procs = @db.conversion_procs
     procs[3909].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').should == [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
     procs[3911].call('{"[2011-10-20 11:12:13,2011-10-20 11:12:14]"}').should == [Time.local(2011, 10, 20, 11, 12, 13)..Time.local(2011, 10, 20, 11, 12, 14)]
   end
@@ -240,8 +245,26 @@ describe "pg_range extension" do
       @r3.db_type.should == 'int8range'
     end
 
-    it "should be able to be created by Range#pg_range" do
-      (1..2).pg_range.should == @r1
+    it "should be able to be created by Sequel.pg_range" do
+      Sequel.pg_range(1..2).should == @r1
+    end
+
+    it "should have Sequel.pg_range be able to take a database type" do
+      Sequel.pg_range(1..2, :int4range).should == @R.new(1, 2, :db_type=>:int4range)
+    end
+
+    it "should have Sequel.pg_range return a PGRange as is" do
+      a = Sequel.pg_range(1..2)
+      Sequel.pg_range(a).should equal(a)
+    end
+
+    it "should have Sequel.pg_range return a new PGRange if the database type differs" do
+      a = Sequel.pg_range(1..2, :int4range)
+      b = Sequel.pg_range(a, :int8range)
+      a.to_range.should == b.to_range
+      a.should_not equal(b)
+      a.db_type.should == :int4range
+      b.db_type.should == :int8range
     end
 
     it "should have #initialize raise if requesting an empty range with beginning or ending" do

data/spec/extensions/pg_row_ops_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Postgres::PGRowOp" do
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @a = Sequel.pg_row_op(:a)
+  end
+
+  it "#[] should access members of the composite type" do
+    @db.literal(@a[:b]).should == "(a).b"
+  end
+
+  it "#[] should be chainable" do
+    @db.literal(@a[:b][:c]).should == "((a).b).c"
+  end
+
+  it "#[] should support array access if not given an identifier" do
+    @db.literal(@a[:b][1]).should == "(a).b[1]"
+  end
+
+  it "#[] should be chainable with array access" do
+    @db.literal(@a[1][:b]).should == "(a[1]).b"
+  end
+
+  it "#splat should return a splatted argument" do
+    @db.literal(@a.splat).should == "(a.*)"
+  end
+
+  it "#splat(type) should return a splatted argument cast to given type" do
+    @db.literal(@a.splat(:b)).should == "(a.*)::b"
+  end
+
+  it "#splat should not work on an already accessed composite type" do
+    proc{@a[:a].splat(:b)}.should raise_error(Sequel::Error)
+  end
+
+  it "#pg_row should be callable on literal strings" do
+    @db.literal(Sequel.lit('a').pg_row[:b]).should == "(a).b"
+  end
+
+  it "#pg_row should be callable on Sequel expressions" do
+    @db.literal(Sequel.function(:a).pg_row[:b]).should == "(a()).b"
+  end
+
+  it "Sequel.pg_row should work as well if the pg_row extension is loaded" do
+    @db.literal(Sequel.pg_row(Sequel.function(:a))[:b]).should == "(a()).b"
+  end
+end

data/spec/extensions/pg_row_plugin_spec.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::PgRow" do
+  before(:all) do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extension(:pg_array)
+    @c = Class.new(Sequel::Model(@db[:address]))
+    @c.columns :street, :city
+    @c.db_schema[:street][:type] = :string
+    @c.db_schema[:city][:type] = :string
+    @db.fetch = [[{:oid=>1098, :typrelid=>2, :typarray=>3}], [{:attname=>'street', :atttypid=>1324}, {:attname=>'city', :atttypid=>1324}]]
+    @c.plugin :pg_row
+
+    @c2 = Class.new(Sequel::Model(@db[:company]))
+    @c2.columns :address
+    @c2.db_schema[:address].merge!(:type=>:pg_row_address)
+  end
+
+  it "should set up a parser for the type that creates a model class" do
+    @db.conversion_procs[1098].call('(123 Foo St,Bar City)').should == @c.load(:street=>'123 Foo St', :city=>'Bar City')
+  end
+
+  it "should set up type casting for the type" do
+    @c2.new(:address=>{'street'=>123, 'city'=>:Bar}).address.should == @c.load(:street=>'123', :city=>'Bar')
+  end
+
+  it "should return model instances as is when typecasting to rows" do
+    o = @c.load(:street=>'123', :city=>'Bar')
+    @c2.new(:address=>o).address.should equal(o)
+  end
+
+  it "should handle literalizing model instances" do
+    @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).should == "ROW('123 Foo St', 'Bar City')::address"
+  end
+
+  it "should handle model instances in bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(@c.load(:street=>'123 Foo St', :city=>'Bar City'), nil).should == '("123 Foo St","Bar City")'
+  end
+
+  it "should handle model instances in arrays of bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(Sequel.pg_array([@c.load(:street=>'123 Foo St', :city=>'Bar City')]), nil).should == '{"(\\"123 Foo St\\",\\"Bar City\\")"}'
+  end
+end

data/spec/extensions/pg_row_spec.rb

@@ -0,0 +1,323 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_row extension" do
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extension(:pg_array, :pg_row)
+    @m = Sequel::Postgres::PGRow
+    @db.sqls
+  end
+
+  it "should parse record objects as arrays" do
+    a = Sequel::Postgres::PG_TYPES[2249].call("(a,b,c)")
+    a.should be_a_kind_of(@m::ArrayRow)
+    a.to_a.should be_a_kind_of(Array)
+    a[0].should == 'a'
+    a.should == %w'a b c'
+    a.db_type.should == nil
+    @db.literal(a).should == "ROW('a', 'b', 'c')"
+  end
+
+  it "should parse arrays of record objects as arrays of arrays" do
+    as = Sequel::Postgres::PG_TYPES[2287].call('{"(a,b,c)","(d,e,f)"}')
+    as.should == [%w'a b c', %w'd e f']
+    as.each do |a|
+      a.should be_a_kind_of(@m::ArrayRow)
+      a.to_a.should be_a_kind_of(Array)
+      a.db_type.should == nil
+    end
+    @db.literal(as).should == "ARRAY[ROW('a', 'b', 'c'),ROW('d', 'e', 'f')]::record[]"
+  end
+
+  it "should be able to register custom parsing of row types as array-like objects" do
+    klass = @m::ArrayRow.subclass(:foo)
+    parser = @m::Parser.new(:converter=>klass)
+    a = parser.call("(a,b,c)")
+    a.should be_a_kind_of(klass)
+    a.to_a.should be_a_kind_of(Array)
+    a[0].should == 'a'
+    a.should == %w'a b c'
+    a.db_type.should == :foo
+    @db.literal(a).should == "ROW('a', 'b', 'c')::foo"
+  end
+
+  it "should be able to register custom parsing of row types as hash-like objects" do
+    klass = @m::HashRow.subclass(:foo, [:a, :b, :c])
+    parser = @m::Parser.new(:converter=>klass, :columns=>[:a, :b, :c])
+    a = parser.call("(a,b,c)")
+    a.should be_a_kind_of(klass)
+    a.to_hash.should be_a_kind_of(Hash)
+    a[:a].should == 'a'
+    a.should == {:a=>'a', :b=>'b', :c=>'c'}
+    a.db_type.should == :foo
+    a.columns.should == [:a, :b, :c]
+    @db.literal(a).should == "ROW('a', 'b', 'c')::foo"
+  end
+
+  it "should raise an error if attempting to literalize a HashRow without column information" do
+    h = @m::HashRow.call(:a=>'a', :b=>'b', :c=>'c')
+    proc{@db.literal(h)}.should raise_error(Sequel::Error)
+  end
+
+  it "should be able to manually override db_type per ArrayRow instance" do
+    a = @m::ArrayRow.call(%w'a b c')
+    a.db_type = :foo
+    @db.literal(a).should == "ROW('a', 'b', 'c')::foo"
+  end
+
+  it "should be able to manually override db_type and columns per HashRow instance" do
+    h = @m::HashRow.call(:a=>'a', :c=>'c', :b=>'b')
+    h.db_type = :foo
+    h.columns = [:a, :b, :c]
+    @db.literal(h).should == "ROW('a', 'b', 'c')::foo"
+  end
+
+  it "should correctly split an empty row" do
+    @m::Splitter.new("()").parse.should == [nil]
+  end
+
+  it "should correctly split a row with a single value" do
+    @m::Splitter.new("(1)").parse.should == %w'1'
+  end
+
+  it "should correctly split a row with multiple values" do
+    @m::Splitter.new("(1,2)").parse.should == %w'1 2'
+  end
+
+  it "should correctly NULL values when splitting" do
+    @m::Splitter.new("(1,)").parse.should == ['1', nil]
+  end
+
+  it "should correctly empty string values when splitting" do
+    @m::Splitter.new('(1,"")').parse.should == ['1', '']
+  end
+
+  it "should handle quoted values when splitting" do
+    @m::Splitter.new('("1","2")').parse.should == %w'1 2'
+  end
+
+  it "should handle escaped backslashes in quoted values when splitting" do
+    @m::Splitter.new('("\\\\1","2\\\\")').parse.should == ['\\1', '2\\']
+  end
+
+  it "should handle doubled quotes in quoted values when splitting" do
+    @m::Splitter.new('("""1","2""")').parse.should == ['"1', '2"']
+  end
+
+  it "should correctly convert types when parsing into an array" do
+    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}]).call("(a,b,c)").should == %w'aa bbb cccc'
+  end
+
+  it "should correctly convert types into hashes if columns are known" do
+    @m::Parser.new(:columns=>[:a, :b, :c]).call("(a,b,c)").should == {:a=>'a', :b=>'b', :c=>'c'}
+  end
+
+  it "should correctly handle type conversion when converting into hashes" do
+    @m::Parser.new(:column_converters=>[proc{|s| s*2}, proc{|s| s*3}, proc{|s| s*4}], :columns=>[:a, :b, :c]).call("(a,b,c)").should == {:a=>'aa', :b=>'bbb', :c=>'cccc'}
+  end
+
+  it "should correctly wrap arrays when converting" do
+    @m::Parser.new(:converter=>proc{|s| [:foo, s]}).call("(a,b,c)").should == [:foo, %w'a b c']
+  end
+
+  it "should correctly wrap hashes when converting" do
+    @m::Parser.new(:converter=>proc{|s| [:foo, s]}, :columns=>[:a, :b, :c]).call("(a,b,c)").should == [:foo, {:a=>'a', :b=>'b', :c=>'c'}]
+  end
+
+  it "should have parser store reflection information" do
+    p = @m::Parser.new(:oid=>1, :column_oids=>[2], :columns=>[:a], :converter=>Array, :typecaster=>Hash, :column_converters=>[Array])
+    p.oid.should == 1
+    p.column_oids.should == [2]
+    p.columns.should == [:a]
+    p.converter.should == Array
+    p.typecaster.should == Hash
+    p.column_converters.should == [Array]
+  end
+
+  it "should reload registered row types when reseting conversion procs" do
+    db = Sequel.mock(:host=>'postgres')
+    db.extension(:pg_row)
+    db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    db.sqls
+    db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    db.register_row_type(:foo)
+    db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
+      "SELECT attname, atttypid FROM pg_attribute WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
+  end
+
+  it "should handle ArrayRows and HashRows in bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(@m::ArrayRow.call(["1", "abc\\'\","]), nil).should == '("1","abc\\\\\'\\",")'
+    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\","), nil).should == '("1","abc\\\\\'\\",")'
+  end
+
+  it "should handle ArrayRows and HashRows in arrays in bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg([@m::ArrayRow.call(["1", "abc\\'\","])], nil).should == '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
+    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\",")], nil).should == '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
+  end
+
+  it "should allow registering row type parsers by introspecting system tables" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo)
+    @db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type WHERE ((typtype = 'c') AND (typname = 'foo')) LIMIT 1",
+      "SELECT attname, atttypid FROM pg_attribute WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
+    p1 = @db.conversion_procs[1]
+    p1.columns.should == [:bar, :baz]
+    p1.column_oids.should == [4, 5]
+    p1.column_converters.should == [p4, p5]
+    p1.oid.should == 1
+    @db.send(:schema_column_type, 'foo').should == :pg_row_foo
+    @db.send(:schema_column_type, 'integer').should == :integer
+
+    c = p1.converter
+    c.superclass.should == @m::HashRow
+    c.columns.should == [:bar, :baz]
+    c.db_type.should == :foo
+    p1.typecaster.should == c
+
+    p1.call('(1,b)').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo, %w'1 b').should be_a_kind_of(@m::HashRow)
+    @db.typecast_value(:pg_row_foo, %w'1 b').should == {:bar=>'1', :baz=>'b'}
+    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').should == {:bar=>'1', :baz=>'b'}
+    @db.literal(p1.call('(1,b)')).should == "ROW(1, 'bb')::foo"
+  end
+
+  it "should allow registering row type parsers for schema qualify types" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo__bar)
+    @db.sqls.should == ["SELECT pg_type.oid, typrelid, typarray FROM pg_type INNER JOIN pg_namespace ON ((pg_namespace.oid = pg_type.typnamespace) AND (pg_namespace.nspname = 'foo')) WHERE ((typtype = 'c') AND (typname = 'bar')) LIMIT 1",
+      "SELECT attname, atttypid FROM pg_attribute WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
+    p1 = @db.conversion_procs[1]
+    p1.columns.should == [:bar, :baz]
+    p1.column_oids.should == [4, 5]
+    p1.column_converters.should == [p4, p5]
+    p1.oid.should == 1
+
+    c = p1.converter
+    c.superclass.should == @m::HashRow
+    c.columns.should == [:bar, :baz]
+    c.db_type.should == :foo__bar
+    p1.typecaster.should == c
+
+    p1.call('(1,b)').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo__bar, %w'1 b').should == {:bar=>'1', :baz=>'b'}
+    @db.typecast_value(:pg_row_foo__bar, :bar=>'1', :baz=>'b').should == {:bar=>'1', :baz=>'b'}
+    @db.literal(p1.call('(1,b)')).should == "ROW(1, 'bb')::foo.bar"
+  end
+
+  it "should allow registering with a custom converter" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    c = proc{|h| [h]}
+    @db.register_row_type(:foo, :converter=>c)
+    o = @db.conversion_procs[1].call('(1,b)')
+    o.should == [{:bar=>1, :baz=>'bb'}]
+    o.first.should be_a_kind_of(Hash)
+  end
+
+  it "should allow registering with a custom typecaster" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
+    @db.typecast_value(:pg_row_foo, %w'1 b').should be_a_kind_of(Hash)
+    @db.typecast_value(:pg_row_foo, %w'1 b').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').should == {:bar=>0, :baz=>'aa'}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar] || h['bar'] || 0).to_i, :baz=>(h[:baz] || h['baz'] || 'a')*2}})
+    @db.typecast_value(:pg_row_foo, %w'1 b').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo, :bar=>'1', :baz=>'b').should == {:bar=>1, :baz=>'bb'}
+    @db.typecast_value(:pg_row_foo, 'bar'=>'1', 'baz'=>'b').should == {:bar=>1, :baz=>'bb'}
+  end
+
+  it "should handle conversion procs that aren't added until later" do
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    c = proc{|h| [h]}
+    @db.register_row_type(:foo, :converter=>c)
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[1].call('(1,b)').should == [{:bar=>1, :baz=>'bb'}]
+  end
+
+  it "should registering array type for row type if type has an array oid" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo, :typecaster=>proc{|h| {:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2}})
+    p3 = @db.conversion_procs[3]
+
+    p3.call('{"(1,b)"}').should == [{:bar=>1, :baz=>'bb'}]
+    @db.literal(p3.call('{"(1,b)"}')).should == "ARRAY[ROW(1, 'bb')::foo]::foo[]"
+    @db.typecast_value(:foo_array, [{:bar=>'1', :baz=>'b'}]).should == [{:bar=>1, :baz=>'bb'}]
+  end
+
+  it "should allow creating unregisted row types via Database#row_type" do
+    @db.literal(@db.row_type(:foo, [1, 2])).should == 'ROW(1, 2)::foo'
+  end
+
+  it "should allow typecasting of registered row types via Database#row_type" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo, :typecaster=>proc{|h| @m::HashRow.subclass(:foo, [:bar, :baz]).new({:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2})})
+    @db.literal(@db.row_type(:foo, ['1', 'b'])).should == "ROW(1, 'bb')::foo"
+    @db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'})).should == "ROW(1, 'bb')::foo"
+  end
+
+  it "should allow parsing when typecasting registered row types via Database#row_type" do
+    @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
+    @db.register_row_type(:foo, :typecaster=>proc{|h| @m::HashRow.subclass(:foo, [:bar, :baz]).new(:bar=>(h[:bar]||0).to_i, :baz=>(h[:baz] || 'a')*2)})
+    @db.literal(@db.row_type(:foo, ['1', 'b'])).should == "ROW(1, 'bb')::foo"
+  end
+
+  it "should raise an error if attempt to use Database#row_type with an unregistered type and hash" do
+    proc{@db.literal(@db.row_type(:foo, {:bar=>'1', :baz=>'b'}))}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempt to use Database#row_type with an unhandled type" do
+    proc{@db.literal(@db.row_type(:foo, 1))}.should raise_error(Sequel::Error)
+  end
+
+  it "should return ArrayRow and HashRow values as-is" do
+    h = @m::HashRow.call(:a=>1)
+    a = @m::ArrayRow.call([1])
+    @db.row_type(:foo, h).should equal(h)
+    @db.row_type(:foo, a).should equal(a)
+  end
+
+  it "should have Sequel.pg_row return a plain ArrayRow" do
+    @db.literal(Sequel.pg_row([1, 2, 3])).should == 'ROW(1, 2, 3)'
+  end
+
+  it "should raise an error if attempting to typecast a hash for a parser without columns" do
+    proc{@m::Parser.new.typecast(:a=>1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if attempting to typecast a unhandled value for a parser" do
+    proc{@m::Parser.new.typecast(1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should handle typecasting for a parser without a typecaster" do
+    @m::Parser.new.typecast([1]).should == [1]
+  end
+
+  it "should raise an error if no columns are returned when registering a custom row type" do
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}]]
+    proc{@db.register_row_type(:foo)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error when registering a custom row type if the type is found found" do
+    @db.fetch = []
+    proc{@db.register_row_type(:foo)}.should raise_error(Sequel::Error)
+  end
+end