sequel 3.46.0 → 3.47.0

data/spec/extensions/looser_typecasting_spec.rb

@@ -31,6 +31,6 @@ describe "LooserTypecasting Extension" do
 
   specify "should not affect conversions of other types in decimal columns" do
     @c.new(:d=>1).d.should == 1
-    @c.new(:d=>'a').d.should be_a_kind_of(BigDecimal)
+    @c.new(:d=>1).d.should be_a_kind_of(BigDecimal)
   end
 end

data/spec/extensions/many_through_many_spec.rb

@@ -297,7 +297,7 @@ describe Sequel::Model, "many_through_many" do
     MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']
   end
 
-  it "should set cached instance variable when accessed" do
+  it "should populate cache when accessed" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
     n.associations[:tags].should == nil
@@ -308,7 +308,7 @@ describe Sequel::Model, "many_through_many" do
     MODEL_DB.sqls.length.should == 0
   end
 
-  it "should use cached instance variable if available" do
+  it "should use cache if available" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
     n.associations[:tags] = []
@@ -316,7 +316,7 @@ describe Sequel::Model, "many_through_many" do
     MODEL_DB.sqls.should == []
   end
 
-  it "should not use cached instance variable if asked to reload" do
+  it "should not use cache if asked to reload" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
     n.associations[:tags] = []
@@ -354,7 +354,6 @@ describe Sequel::Model, "many_through_many" do
   end
 
   it "should support a :uniq option that removes duplicates from the association" do
-    h = []
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :uniq=>true
     @c2.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
     @c1.load(:id=>10).tags.should == [@c2.load(:id=>20), @c2.load(:id=>30)]

data/spec/extensions/many_to_one_pk_lookup_spec.rb

@@ -2,7 +2,9 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::ManyToOnePkLookup" do
   before do
-    class ::LookupModel < ::Sequel::Model
+    @db = Sequel.mock
+
+    class ::LookupModel < ::Sequel::Model(@db)
       plugin :many_to_one_pk_lookup
       columns :id, :caching_model_id, :caching_model_id2
       many_to_one :caching_model
@@ -10,12 +12,10 @@ describe "Sequel::Plugins::ManyToOnePkLookup" do
     end
     @c = LookupModel
 
-    class ::CachingModel < Sequel::Model
+    class ::CachingModel < Sequel::Model(@db)
       columns :id, :id2
     end
     @cc = CachingModel
-
-    @db = MODEL_DB
   end
   after do
     Object.send(:remove_const, :CachingModel)
@@ -23,25 +23,25 @@ describe "Sequel::Plugins::ManyToOnePkLookup" do
   end
 
   shared_examples_for "many_to_one_pk_lookup with composite keys" do
-    it "should use a simple primary key lookup when retrieving many_to_one associated records" do
+    it "should use a simple primary key lookup when retrieving many_to_one associated records with a composite key" do
       @db.sqls.should == []
       @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.should equal(@cm12)
       @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.should equal(@cm21)
       @db.sqls.should == []
-      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2
-      @db.sqls.should_not == []
+      @cc.dataset._fetch = []
+      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2.should == nil
     end
   end
 
   shared_examples_for "many_to_one_pk_lookup" do
-    it "should use a simple primary key lookup when retrieving many_to_one associated records via a composite key" do
+    it "should use a simple primary key lookup when retrieving many_to_one associated records" do
       @cc.set_primary_key([:id, :id2])
       @db.sqls.should == []
       @c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
       @c.load(:id=>4, :caching_model_id=>2).caching_model.should equal(@cm2)
       @db.sqls.should == []
-      @c.load(:id=>4, :caching_model_id=>3).caching_model
-      @db.sqls.should_not == []
+      @cc.dataset._fetch = []
+      @c.load(:id=>4, :caching_model_id=>3).caching_model.should == nil
     end
 
     it "should not use a simple primary key lookup if the assocation has a nil :key option" do
@@ -62,10 +62,41 @@ describe "Sequel::Plugins::ManyToOnePkLookup" do
       @db.sqls.should_not == []
     end
 
+    it "should not use a simple primary key lookup if the assocation has :conditions" do
+      @c.many_to_one :caching_model, :conditions=>{:a=>1}
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the assocation has :select" do
+      @c.many_to_one :caching_model, :select=>[:a, :b]
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the assocation has a block" do
+      @c.many_to_one(:caching_model){|ds| ds.where{a > 1}}
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should not use a simple primary key lookup if the assocation has a non-default :dataset option" do
+      cc = @cc
+      @c.many_to_one :caching_model, :dataset=>proc{cc.where(:id=>caching_model_id)}
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should_not == []
+    end
+
+    it "should use a simple primary key lookup if explicitly set" do
+      @c.many_to_one :caching_model, :select=>[:a, :b], :many_to_one_pk_lookup=>true
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should == []
+    end
+
     it "should not use a simple primary key lookup if the prepared_statements_associations method is being used" do
-      c2 = Class.new(Sequel::Model(:not_caching_model))
+      c2 = Class.new(Sequel::Model(@db[:not_caching_model]))
       c2.dataset._fetch = {:id=>1}
-      c = Class.new(Sequel::Model(:lookup_model))
+      c = Class.new(Sequel::Model(@db[:lookup_model]))
       c.class_eval do
         plugin :prepared_statements_associations
         plugin :many_to_one_pk_lookup
@@ -106,7 +137,7 @@ describe "Sequel::Plugins::ManyToOnePkLookup" do
       @cm12 = @cc[1, 2]
       @cm21 = @cc[2, 1]
 
-      @db.reset
+      @db.sqls
     end
 
     it_should_behave_like "many_to_one_pk_lookup"
@@ -119,10 +150,17 @@ describe "Sequel::Plugins::ManyToOnePkLookup" do
       @cc.plugin :static_cache
       @cm1 = @cc[1]
       @cm2 = @cc[2]
-      @db.reset
+      @db.sqls
     end
 
     it_should_behave_like "many_to_one_pk_lookup"
+
+    it "should not issue regular query if primary key lookup returns no rows" do
+      def @cc.primary_key_lookup(pk); end
+      @c.many_to_one :caching_model
+      @c.load(:id=>3, :caching_model_id=>1).caching_model
+      @db.sqls.should == []
+    end
   end
 
   describe "With static_cache plugin with composite key" do
@@ -132,7 +170,7 @@ describe "Sequel::Plugins::ManyToOnePkLookup" do
       @cc.plugin :static_cache
       @cm12 = @cc[[1, 2]]
       @cm21 = @cc[[2, 1]]
-      @db.reset
+      @db.sqls
     end
 
     it_should_behave_like "many_to_one_pk_lookup with composite keys"

data/spec/extensions/migration_spec.rb

@@ -259,6 +259,10 @@ describe "Sequel::IntegerMigrator" do
   specify "should raise and error if there is a missing integer migration version" do
     proc{Sequel::Migrator.apply(@db, "spec/files/missing_integer_migrations")}.should raise_error(Sequel::Migrator::Error)
   end
+  
+  specify "should not raise and error if there is a missing integer migration version and allow_missing_migration_files is true" do
+    Sequel::Migrator.run(@db, "spec/files/missing_integer_migrations", :allow_missing_migration_files => true).should_not raise_error(Sequel::Migrator::Error)
+  end
 
   specify "should raise and error if there is a duplicate integer migration version" do
     proc{Sequel::Migrator.apply(@db, "spec/files/duplicate_integer_migrations")}.should raise_error(Sequel::Migrator::Error)
@@ -609,6 +613,18 @@ describe "Sequel::TimestampMigrator" do
     @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
   end
   
+  specify "should not raise error for applied migrations not in file system if :allow_missing_migration_files is true" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+
+    @dir = 'spec/files/missing_timestamped_migrations'
+    proc{@m.run(@db, @dir, :allow_missing_migration_files => true)}.should_not raise_error(Sequel::Migrator::Error)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).should be_true}
+    @db[:schema_migrations].select_order_map(:filename).should == %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+  end
+  
   specify "should raise error missing column name in existing schema_migrations table" do
     @dir = 'spec/files/timestamped_migrations'
     @m.apply(@db, @dir)

data/spec/extensions/null_dataset_spec.rb

@@ -71,7 +71,7 @@ describe "null_dataset extension" do
     @i.should == 1
   end
 
-  it "should have null! method modify receiver" do
+  it "should have nullify! method modify receiver" do
     ds = @db[:table]
     ds.nullify!.should equal(ds)
     ds.each(&@pr)

data/spec/extensions/pg_array_spec.rb

@@ -14,6 +14,7 @@ describe "pg_array extension" do
     @db.extension(:pg_array)
     @m = Sequel::Postgres
     @converter = @m::PG_TYPES
+    @db.sqls
   end
 
   it "should parse single dimensional text arrays" do
@@ -300,7 +301,7 @@ describe "pg_array extension" do
     Sequel::Postgres::PG_TYPES[2].should be_a_kind_of(Sequel::Postgres::PGArray::JSONCreator)
   end
 
-  it "should support registering converters with :parser=>:json option" do
+  it "should support registering converters with :parser=>:json option and blocks" do
     Sequel::Postgres::PGArray.register('foo', :oid=>4, :parser=>:json){|s| s * 2}
     Sequel::Postgres::PG_TYPES[4].call('{{1, 2}, {3, 4}}').should == [[2, 4], [6, 8]]
   end
@@ -316,9 +317,55 @@ describe "pg_array extension" do
     @db.schema(:items).map{|e| e[1][:type]}.should == [:float_array]
   end
 
+  it "should support registering custom array types on a per-Database basis" do
+    @db.register_array_type('banana', :oid=>7865){|s| s}
+    @db.typecast_value(:banana_array, []).should be_a_kind_of(Sequel::Postgres::PGArray)
+    @db.fetch = [{:name=>'id', :db_type=>'banana[]'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:banana_array]
+    @db.conversion_procs.should have_key(7865)
+    @db.respond_to?(:typecast_value_banana_array, true).should be_true
+
+    db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
+    db.extension(:pg_array)
+    db.fetch = [{:name=>'id', :db_type=>'banana[]'}]
+    db.schema(:items).map{|e| e[1][:type]}.should == [nil]
+    db.conversion_procs.should_not have_key(7865)
+    db.respond_to?(:typecast_value_banana_array, true).should be_false
+  end
+
+  it "should automatically look up the array and scalar oids when registering per-Database types" do
+    @db.fetch = [[{:oid=>21, :typarray=>7866}], [{:name=>'id', :db_type=>'banana[]'}]]
+    @db.register_array_type('banana', :scalar_typecast=>:integer)
+    @db.sqls.should == ["SELECT typarray, oid FROM pg_type WHERE (typname = 'banana') LIMIT 1"]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:banana_array]
+    @db.conversion_procs[7866].call("{1,2}").should == [1,2]
+    @db.typecast_value(:banana_array, %w'1 2').should == [1,2]
+  end
+
+  it "should not automatically look up oids if given both scalar and array oids" do
+    @db.register_array_type('banana', :oid=>7866, :scalar_oid=>21, :scalar_typecast=>:integer)
+    @db.sqls.should == []
+    @db.conversion_procs[7866].call("{1,2}").should == [1,2]
+    @db.typecast_value(:banana_array, %w'1 2').should == [1,2]
+  end
+
+  it "should not automatically look up oids if given array oid and block" do
+    @db.register_array_type('banana', :oid=>7866, :scalar_typecast=>:integer){|s| s.to_i}
+    @db.sqls.should == []
+    @db.conversion_procs[7866].call("{1,2}").should == [1,2]
+    @db.typecast_value(:banana_array, %w'1 2').should == [1,2]
+  end
+
   it "should set appropriate timestamp conversion procs when getting conversion procs" do
     procs = @db.conversion_procs
     procs[1185].call('{"2011-10-20 11:12:13"}').should == [Time.local(2011, 10, 20, 11, 12, 13)]
     procs[1115].call('{"2011-10-20 11:12:13"}').should == [Time.local(2011, 10, 20, 11, 12, 13)]
   end
+
+  it "should return correct results for Database#schema_type_class" do
+    @db.register_array_type('banana', :oid=>7866, :scalar_typecast=>:integer){|s| s.to_i}
+    @db.schema_type_class(:banana_array).should == Sequel::Postgres::PGArray
+    @db.schema_type_class(:integer).should == Integer
+  end
 end

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -7,11 +7,19 @@ describe "Sequel::Postgres::HStoreOp" do
   end
 
   it "#- should use the - operator" do
-    @ds.literal(@h - 'a').should == "(h - 'a')"
+    @ds.literal(@h - :a).should == "(h - a)"
+  end
+
+  it "#- should cast String argument to text when using - operator" do
+    @ds.literal(@h - 'a').should == "(h - CAST('a' AS text))"
+  end
+
+  it "#- should not cast LiteralString argument to text when using - operator" do
+    @ds.literal(@h - Sequel.lit('a')).should == "(h - a)"
   end
 
   it "#- should return an HStoreOp" do
-    @ds.literal((@h - 'a')['a']).should == "((h - 'a') -> 'a')"
+    @ds.literal((@h - :a)['a']).should == "((h - a) -> 'a')"
   end
 
   it "#[] should use the -> operator" do

data/spec/extensions/pg_hstore_spec.rb

@@ -197,4 +197,9 @@ describe "pg_hstore extension" do
     dump = Marshal.dump(v) 
     Marshal.load(dump).should == v    
   end 
+
+  it "should return correct results for Database#schema_type_class" do
+    @db.schema_type_class(:hstore).should == Sequel::Postgres::HStore
+    @db.schema_type_class(:integer).should == Integer
+  end
 end

data/spec/extensions/pg_inet_spec.rb

@@ -44,4 +44,9 @@ describe "pg_inet extension" do
     proc{@db.typecast_value(:ipaddr, '')}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:ipaddr, 1)}.should raise_error(Sequel::InvalidValue)
   end
+
+  it "should return correct results for Database#schema_type_class" do
+    @db.schema_type_class(:ipaddr).should == IPAddr
+    @db.schema_type_class(:integer).should == Integer
+  end
 end

data/spec/extensions/pg_interval_spec.rb

@@ -2,8 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 begin
   require 'active_support/duration'
-rescue LoadError => e
-  skip_warn "pg_interval plugin: can't load active_support/duration (#{e.class}: #{e})"
+rescue LoadError => exc
+  skip_warn "pg_interval plugin: can't load active_support/duration (#{exc.class}: #{exc})"
 else
 describe "pg_interval extension" do
   before do
@@ -46,7 +46,6 @@ describe "pg_interval extension" do
   end
 
   it "should support typecasting for the interval type" do
-    ip = IPAddr.new('127.0.0.1')
     d = ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
     @db.typecast_value(:interval, d).object_id.should == d.object_id
 
@@ -68,5 +67,10 @@ describe "pg_interval extension" do
     proc{@db.typecast_value(:interval, 'foo')}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:interval, Object.new)}.should raise_error(Sequel::InvalidValue)
   end
+
+  it "should return correct results for Database#schema_type_class" do
+    @db.schema_type_class(:interval).should == ActiveSupport::Duration
+    @db.schema_type_class(:integer).should == Integer
+  end
 end
 end

data/spec/extensions/pg_json_spec.rb

@@ -55,7 +55,7 @@ describe "pg_json extension" do
     end
   end
 
-  it "should literalize HStores to strings correctly" do
+  it "should literalize JSONHash and JSONArray to strings correctly" do
     @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"
@@ -110,4 +110,9 @@ describe "pg_json extension" do
     proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
     proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
   end
+
+  it "should return correct results for Database#schema_type_class" do
+    @db.schema_type_class(:json).should == [Sequel::Postgres::JSONHash, Sequel::Postgres::JSONArray]
+    @db.schema_type_class(:integer).should == Integer
+  end
 end

data/spec/extensions/pg_range_ops_spec.rb

@@ -33,9 +33,12 @@ describe "Sequel::Postgres::RangeOp" do
     @ds.literal(@h.overlaps(@h)).should == "(h && h)"
     @ds.literal(@h.left_of(@h)).should == "(h << h)"
     @ds.literal(@h.right_of(@h)).should == "(h >> h)"
+    @ds.literal(@h.ends_before(@h)).should == "(h &< h)"
+    @ds.literal(@h.starts_after(@h)).should == "(h &> h)"
+    @ds.literal(@h.adjacent_to(@h)).should == "(h -|- h)"
+
     @ds.literal(@h.starts_before(@h)).should == "(h &< h)"
     @ds.literal(@h.ends_after(@h)).should == "(h &> h)"
-    @ds.literal(@h.adjacent_to(@h)).should == "(h -|- h)"
   end
 
   it "should define methods for all of the the PostgreSQL range functions" do

data/spec/extensions/pg_range_spec.rb

@@ -163,6 +163,11 @@ describe "pg_range extension" do
     Sequel::Postgres::PG_TYPES[331].call('[1,3)').should be_a_kind_of(@R)
   end
 
+  it "should return correct results for Database#schema_type_class" do
+    @db.schema_type_class(:int4range).should == Sequel::Postgres::PGRange
+    @db.schema_type_class(:integer).should == Integer
+  end
+
   describe "parser" do
     before do
       @p = Sequel::Postgres::PG_TYPES[3904]

data/spec/extensions/pg_row_plugin_spec.rb

@@ -15,6 +15,14 @@ describe "Sequel::Plugins::PgRow" do
     @c2.columns :address
     @c2.db_schema[:address].merge!(:type=>:pg_row_address)
   end
+  after do
+    @c.dataset.opts[:from] = [:address]
+  end
+
+  it "should have schema_type_class include Sequel::Model" do
+    @c2.new.send(:schema_type_class, :address).should == @c
+    @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 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')
@@ -33,6 +41,11 @@ describe "Sequel::Plugins::PgRow" do
     @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).should == "ROW('123 Foo St', 'Bar City')::address"
   end
 
+  it "should handle literalizing model instances when model table is aliased" do
+    @c.dataset.opts[:from] = [Sequel.as(:address, :a)]
+    @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")'

data/spec/extensions/pg_row_spec.rb

@@ -137,13 +137,13 @@ describe "pg_row extension" do
   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.conversion_procs[4] = proc{|s| s.to_i}
+    db.conversion_procs[5] = 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"]
+      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
 
     begin
       pgnt = Sequel::Postgres::PG_NAMED_TYPES.dup
@@ -151,7 +151,7 @@ describe "pg_row extension" do
       db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}, {:attname=>'baz', :atttypid=>5}]]
       db.reset_conversion_procs
       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"]
+        "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) WHERE ((attrelid = 2) AND (attnum > 0) AND NOT attisdropped) ORDER BY attnum"]
     ensure
       Sequel::Postgres::PG_NAMED_TYPES.replace pgnt
     end
@@ -182,7 +182,7 @@ describe "pg_row extension" do
     @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"]
+      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) 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]
@@ -210,7 +210,7 @@ describe "pg_row extension" do
     @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"]
+      "SELECT attname, (CASE pg_type.typbasetype WHEN 0 THEN atttypid ELSE pg_type.typbasetype END) AS atttypid FROM pg_attribute INNER JOIN pg_type ON (pg_type.oid = pg_attribute.atttypid) 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]
@@ -230,8 +230,8 @@ describe "pg_row extension" do
   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.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = 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)
@@ -241,8 +241,8 @@ describe "pg_row extension" do
   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.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = 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)
@@ -257,16 +257,16 @@ describe "pg_row extension" do
   end
 
   it "should handle conversion procs that aren't added until later" do
-    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.conversion_procs[5] = 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[4] = proc{|s| s.to_i}
     @db.conversion_procs[1].call('(1,b)').should == [{:bar=>1, :baz=>'bb'}]
   end
 
   it "should handle nil values when converting columns" do
-    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.conversion_procs[5] = proc{|s| s * 2}
     @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}]]
     called = false
     @db.conversion_procs[4] = proc{|s| called = true; s}
@@ -276,8 +276,8 @@ describe "pg_row extension" do
   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.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = 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]
@@ -292,8 +292,8 @@ describe "pg_row extension" do
   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.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = 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"
@@ -301,8 +301,8 @@ describe "pg_row extension" do
   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.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = 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"
@@ -348,4 +348,13 @@ describe "pg_row extension" do
     @db.fetch = []
     proc{@db.register_row_type(:foo)}.should raise_error(Sequel::Error)
   end
+
+  it "should return correct results for Database#schema_type_class" do
+    @db.conversion_procs[4] = proc{|s| s.to_i}
+    @db.conversion_procs[5] = 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.schema_type_class(:pg_row_foo).should == [Sequel::Postgres::PGRow::HashRow, Sequel::Postgres::PGRow::ArrayRow]
+    @db.schema_type_class(:integer).should == Integer
+  end
 end