sequel 3.21.0 → 3.28.0

data/spec/model/associations_spec.rb

@@ -357,6 +357,28 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
   end
   
+  it "should use a callback if given one as the argument" do
+    @c2.many_to_one :parent, :class => @c2
+
+    d = @c2.create(:id => 1)
+    MODEL_DB.reset
+    d.parent_id = 234
+    d.associations[:parent] = 42
+    d.parent(proc{|ds| ds.filter{name > 'M'}}).should_not == 42 
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 234) AND (name > 'M')) LIMIT 1"]
+  end
+  
+  it "should use a block given to the association method as a callback on ruby 1.8.7+" do
+    @c2.many_to_one :parent, :class => @c2
+
+    d = @c2.create(:id => 1)
+    MODEL_DB.reset
+    d.parent_id = 234
+    d.associations[:parent] = 42
+    d.parent{|ds| ds.filter{name > 'M'}}.should_not == 42 
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 234) AND (name > 'M')) LIMIT 1"]
+  end if RUBY_VERSION >= '1.8.7'
+  
   it "should have the setter add to the reciprocal one_to_many cached association list if it exists" do
     @c2.many_to_one :parent, :class => @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
@@ -538,6 +560,19 @@ describe Sequel::Model, "many_to_one" do
     parent.pk.should == 20
   end
 
+  it "should support after_load association callback that changes the cached object" do
+    h = []
+    @c2.many_to_one :parent, :class => @c2, :after_load=>:al
+    @c2.class_eval do
+      def al(v)
+        associations[:parent] = :foo
+      end
+    end
+    p = @c2.load(:id=>10, :parent_id=>20)
+    p.parent.should == :foo
+    p.associations[:parent].should == :foo
+  end
+
   it "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
     # The reason for this is that assignment in ruby always returns the argument instead of the result
     # of the method, so we can't return nil to signal that the association callback prevented the modification
@@ -1149,6 +1184,16 @@ describe Sequel::Model, "one_to_many" do
     v.model.should == Historical::Value
   end
 
+  it "should use a callback if given one as the argument" do
+    @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
+    
+    d = @c2.create(:id => 1234)
+    MODEL_DB.reset
+    d.associations[:attributes] = []
+    d.attributes(proc{|ds| ds.filter{name > 'M'}}).should_not == []
+    MODEL_DB.sqls.should == ["SELECT * FROM attributes WHERE ((attributes.nodeid = 1234) AND (name > 'M'))"]
+  end
+  
   it "should use explicit key if given" do
     @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
     
@@ -1338,7 +1383,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    def a.valid?(opts); false; end
+    def a.validate() errors.add(:id, 'foo') end
     proc{n.add_attribute(a)}.should raise_error(Sequel::Error)
     proc{n.remove_attribute(a)}.should raise_error(Sequel::Error)
   end
@@ -1347,7 +1392,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :validate=>false
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    def a.valid?(opts); false; end
+    def a.validate() errors.add(:id, 'foo') end
     n.add_attribute(a).should == a
     n.remove_attribute(a).should == a
   end
@@ -2250,7 +2295,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1 
     n = @c1.new
     a = @c2.load(:id=>123)
-    def n.valid?(opts); false; end
+    def n.validate() errors.add(:id, 'foo') end
     proc{a.add_attribute(n)}.should raise_error(Sequel::ValidationFailed)
   end
 
@@ -2259,7 +2304,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c1.new
     n.raise_on_save_failure = false
     a = @c2.load(:id=>123)
-    def n.valid?(opts); false; end
+    def n.validate() errors.add(:id, 'foo') end
     proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
   end
 
@@ -2267,7 +2312,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1, :validate=>false
     n = @c1.new
     a = @c2.load(:id=>123)
-    def n.valid?(opts); false; end
+    def n.validate() errors.add(:id, 'foo') end
     a.add_attribute(n)
     n.new?.should == false
   end
@@ -2724,3 +2769,429 @@ describe Sequel::Model, " association reflection methods" do
     c.instance_methods.map{|x| x.to_s}.should include('parent')
   end
 end
+
+describe "Filtering by associations" do
+  before do
+    @Album = Class.new(Sequel::Model(:albums))
+    artist = @Artist = Class.new(Sequel::Model(:artists))
+    tag = @Tag = Class.new(Sequel::Model(:tags))
+    track = @Track = Class.new(Sequel::Model(:tracks))
+    album_info = @AlbumInfo = Class.new(Sequel::Model(:album_infos))
+    @Artist.columns :id, :id1, :id2
+    @Tag.columns :id, :tid1, :tid2
+    @Track.columns :id, :album_id, :album_id1, :album_id2
+    @AlbumInfo.columns :id, :album_id, :album_id1, :album_id2
+    @Album.class_eval do
+      columns :id, :id1, :id2, :artist_id, :artist_id1, :artist_id2
+      many_to_one :artist, :class=>artist
+      one_to_many :tracks, :class=>track, :key=>:album_id
+      one_to_one :album_info, :class=>album_info, :key=>:album_id
+      many_to_many :tags, :class=>tag, :left_key=>:album_id, :join_table=>:albums_tags
+
+      many_to_one :cartist, :class=>artist, :key=>[:artist_id1, :artist_id2], :primary_key=>[:id1, :id2]
+      one_to_many :ctracks, :class=>track, :key=>[:album_id1, :album_id2], :primary_key=>[:id1, :id2]
+      one_to_one :calbum_info, :class=>album_info, :key=>[:album_id1, :album_id2], :primary_key=>[:id1, :id2]
+      many_to_many :ctags, :class=>tag, :left_key=>[:album_id1, :album_id2], :left_primary_key=>[:id1, :id2], :right_key=>[:tag_id1, :tag_id2], :right_primary_key=>[:tid1, :tid2], :join_table=>:albums_tags
+    end
+  end
+
+  it "should be able to filter on many_to_one associations" do
+    @Album.filter(:artist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (artist_id = 3)'
+  end
+
+  it "should be able to filter on one_to_many associations" do
+    @Album.filter(:tracks=>@Track.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE (id = 3)'
+  end
+
+  it "should be able to filter on one_to_one associations" do
+    @Album.filter(:album_info=>@AlbumInfo.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE (id = 3)'
+  end
+
+  it "should be able to filter on many_to_many associations" do
+    @Album.filter(:tags=>@Tag.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id = 3) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>@Artist.load(:id1=>3, :id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1 = 3) AND (artist_id2 = 4))'
+  end
+
+  it "should be able to filter on one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>@Track.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 = 3) AND (id2 = 4))'
+  end
+
+  it "should be able to filter on one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 = 3) AND (id2 = 4))' 
+  end
+
+  it "should be able to filter on many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>@Tag.load(:tid1=>3, :tid2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE ((tag_id1 = 3) AND (tag_id2 = 4) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should work inside a complex filter" do
+    artist = @Artist.load(:id=>3)
+    @Album.filter{foo & {:artist=>artist}}.sql.should == 'SELECT * FROM albums WHERE (foo AND (artist_id = 3))'
+    track = @Track.load(:album_id=>4)
+    @Album.filter{foo & [[:artist, artist], [:tracks, track]]}.sql.should == 'SELECT * FROM albums WHERE (foo AND (artist_id = 3) AND (id = 4))'
+  end
+
+  it "should raise for an invalid association name" do
+    proc{@Album.filter(:foo=>@Artist.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid association type" do
+    @Album.many_to_many :iatags, :clone=>:tags
+    @Album.association_reflection(:iatags)[:type] = :foo
+    proc{@Album.filter(:iatags=>@Tag.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid associated object class " do
+    proc{@Album.filter(:tags=>@Artist.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid associated object class when multiple objects are used" do
+    proc{@Album.filter(:tags=>[@Tag.load(:id=>3), @Artist.load(:id=>3)]).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should correctly handle case when a multiple value association is used" do
+    proc{@Album.filter(:tags=>[@Tag.load(:id=>3), @Artist.load(:id=>3)]).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should not affect non-association IN/NOT IN filtering with an empty array" do
+    @Album.filter(:tag_id=>[]).sql.should == 'SELECT * FROM albums WHERE (tag_id != tag_id)'
+    @Album.exclude(:tag_id=>[]).sql.should == 'SELECT * FROM albums WHERE (1 = 1)'
+  end
+
+  it "should work correctly in subclasses" do
+    c = Class.new(@Album)
+    c.many_to_one :sartist, :class=>@Artist
+    c.filter(:sartist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (sartist_id = 3)'
+  end
+
+  it "should be able to exclude on many_to_one associations" do
+    @Album.exclude(:artist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE ((artist_id != 3) OR (artist_id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many associations" do
+    @Album.exclude(:tracks=>@Track.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE ((id != 3) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one associations" do
+    @Album.exclude(:album_info=>@AlbumInfo.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE ((id != 3) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_many associations" do
+    @Album.exclude(:tags=>@Tag.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id = 3) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>@Artist.load(:id1=>3, :id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1 != 3) OR (artist_id2 != 4) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>@Track.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 != 3) OR (id2 != 4) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>@AlbumInfo.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 != 3) OR (id2 != 4) OR (id1 IS NULL) OR (id2 IS NULL))' 
+  end
+
+  it "should be able to exclude on many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>@Tag.load(:tid1=>3, :tid2=>4)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE ((tag_id1 = 3) AND (tag_id2 = 4) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to filter on multiple many_to_one associations" do
+    @Album.filter(:artist=>[@Artist.load(:id=>3), @Artist.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE (artist_id IN (3, 4))'
+  end
+
+  it "should be able to filter on multiple one_to_many associations" do
+    @Album.filter(:tracks=>[@Track.load(:album_id=>3), @Track.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE (id IN (3, 4))'
+  end
+
+  it "should be able to filter on multiple one_to_one associations" do
+    @Album.filter(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE (id IN (3, 4))'
+  end
+
+  it "should be able to filter on multiple many_to_many associations" do
+    @Album.filter(:tags=>[@Tag.load(:id=>3), @Tag.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3, 4)) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on multiple many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>5, :id2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN ((3, 4), (5, 6)))'
+  end
+
+  it "should be able to filter on multiple one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4), (5, 6)))'
+  end
+
+  it "should be able to filter on multiple one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4), (5, 6)))' 
+  end
+
+  it "should be able to filter on multiple many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5, :tid2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4), (5, 6))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to exclude on multiple many_to_one associations" do
+    @Album.exclude(:artist=>[@Artist.load(:id=>3), @Artist.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((artist_id NOT IN (3, 4)) OR (artist_id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_many associations" do
+    @Album.exclude(:tracks=>[@Track.load(:album_id=>3), @Track.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3, 4)) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_one associations" do
+    @Album.exclude(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3, 4)) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple many_to_many associations" do
+    @Album.exclude(:tags=>[@Tag.load(:id=>3), @Tag.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3, 4)) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>5, :id2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN ((3, 4), (5, 6))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4), (5, 6))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4), (5, 6))) OR (id1 IS NULL) OR (id2 IS NULL))' 
+  end
+
+  it "should be able to exclude on multiple many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5, :tid2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4), (5, 6))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to handle NULL values when filtering many_to_one associations" do
+    @Album.filter(:artist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering one_to_many associations" do
+    @Album.filter(:tracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering one_to_one associations" do
+    @Album.filter(:album_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering many_to_many associations" do
+    @Album.filter(:tags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle filteringing with NULL values for many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>@Artist.load(:id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:cartist=>@Artist.load(:id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:cartist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to filtering with NULL values for one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>@Track.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctracks=>@Track.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to filtering with NULL values for one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\'' 
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\'' 
+    @Album.filter(:calbum_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'f\'' 
+  end
+
+  it "should be able to filtering with NULL values for many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>@Tag.load(:tid1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctags=>@Tag.load(:tid2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when excluding many_to_one associations" do
+    @Album.exclude(:artist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding one_to_many associations" do
+    @Album.exclude(:tracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding one_to_one associations" do
+    @Album.exclude(:album_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding many_to_many associations" do
+    @Album.exclude(:tags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle excluding with NULL values for many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>@Artist.load(:id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:cartist=>@Artist.load(:id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:cartist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to excluding with NULL values for one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>@Track.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctracks=>@Track.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to excluding with NULL values for one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>@AlbumInfo.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\'' 
+    @Album.exclude(:calbum_info=>@AlbumInfo.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\'' 
+    @Album.exclude(:calbum_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'t\'' 
+  end
+
+  it "should be able to excluding with NULL values for many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>@Tag.load(:tid1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctags=>@Tag.load(:tid2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_one associations" do
+    @Album.filter(:artist=>[@Artist.load(:id=>3), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE (artist_id IN (3))'
+    @Album.filter(:artist=>[@Artist.new, @Artist.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple one_to_many associations" do
+    @Album.filter(:tracks=>[@Track.load(:album_id=>3), @Track.new]).sql.should == 'SELECT * FROM albums WHERE (id IN (3))'
+    @Album.filter(:tracks=>[@Track.new, @Track.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple one_to_one associations" do
+    @Album.filter(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE (id IN (3))'
+    @Album.filter(:album_info=>[@AlbumInfo.new, @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_many associations" do
+    @Album.filter(:tags=>[@Tag.load(:id=>3), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3)) AND (album_id IS NOT NULL))))'
+    @Album.filter(:tags=>[@Tag.new, @Tag.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>3)]).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN ((3, 4)))'
+    @Album.filter(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN ((3, 4)))'
+  end
+
+  it "should be able handle NULL values when filtering multiple one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>3)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))'
+    @Album.filter(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.new]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))'
+  end
+
+  it "should be able to handle NULL values when filtering multiple one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))' 
+    @Album.filter(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))' 
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+    @Album.filter(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_one associations" do
+    @Album.exclude(:artist=>[@Artist.load(:id=>3), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE ((artist_id NOT IN (3)) OR (artist_id IS NULL))'
+    @Album.exclude(:artist=>[@Artist.new, @Artist.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple one_to_many associations" do
+    @Album.exclude(:tracks=>[@Track.load(:album_id=>3), @Track.new]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3)) OR (id IS NULL))'
+    @Album.exclude(:tracks=>[@Track.new, @Track.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple one_to_one associations" do
+    @Album.exclude(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3)) OR (id IS NULL))'
+    @Album.exclude(:album_info=>[@AlbumInfo.new, @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_many associations" do
+    @Album.exclude(:tags=>[@Tag.load(:id=>3), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3)) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+    @Album.exclude(:tags=>[@Tag.new, @Tag.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>3)]).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN ((3, 4))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+    @Album.exclude(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN ((3, 4))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able handle NULL values when excluding multiple one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>3)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))'
+    @Album.exclude(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.new]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to handle NULL values when excluding multiple one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))' 
+    @Album.exclude(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))' 
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+    @Album.exclude(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to filter on many_to_one association datasets" do
+    @Album.filter(:artist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (artist_id IN (SELECT id FROM artists WHERE ((x = 1) AND (id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_many association datasets" do
+    @Album.filter(:tracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM tracks WHERE ((x = 1) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_one association datasets" do
+    @Album.filter(:album_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM album_infos WHERE ((x = 1) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_many association datasets" do
+    @Album.filter(:tags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_one association datasets with composite keys" do
+    @Album.filter(:cartist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN (SELECT id1, id2 FROM artists WHERE ((x = 1) AND (id1 IS NOT NULL) AND (id2 IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_many association datasets with composite keys" do
+    @Album.filter(:ctracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM tracks WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_one association datasets with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM album_infos WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_many association datasets with composite keys" do
+    @Album.filter(:ctags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN (SELECT tid1, tid2 FROM tags WHERE ((x = 1) AND (tid1 IS NOT NULL) AND (tid2 IS NOT NULL)))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to exclude on many_to_one association datasets" do
+    @Album.exclude(:artist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((artist_id NOT IN (SELECT id FROM artists WHERE ((x = 1) AND (id IS NOT NULL)))) OR (artist_id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many association datasets" do
+    @Album.exclude(:tracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM tracks WHERE ((x = 1) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one association datasets" do
+    @Album.exclude(:album_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM album_infos WHERE ((x = 1) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_many association datasets" do
+    @Album.exclude(:tags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_one association datasets with composite keys" do
+    @Album.exclude(:cartist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN (SELECT id1, id2 FROM artists WHERE ((x = 1) AND (id1 IS NOT NULL) AND (id2 IS NOT NULL)))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many association datasets with composite keys" do
+    @Album.exclude(:ctracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM tracks WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one association datasets with composite keys" do
+    @Album.exclude(:calbum_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM album_infos WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_many association datasets with composite keys" do
+    @Album.exclude(:ctags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN (SELECT tid1, tid2 FROM tags WHERE ((x = 1) AND (tid1 IS NOT NULL) AND (tid2 IS NOT NULL)))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should do a regular IN query if the dataset for a different model is used" do
+    @Album.filter(:artist=>@Album.select(:x)).sql.should == 'SELECT * FROM albums WHERE (artist IN (SELECT x FROM albums))'
+  end
+
+  it "should do a regular IN query if a non-model dataset is used" do
+    @Album.filter(:artist=>@Album.db.from(:albums).select(:x)).sql.should == 'SELECT * FROM albums WHERE (artist IN (SELECT x FROM albums))'
+  end
+end

data/spec/model/base_spec.rb

@@ -131,6 +131,50 @@ describe Sequel::Model, ".def_dataset_method" do
   end
 end
 
+describe Sequel::Model, ".dataset_module" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+  end
+  
+  it "should extend the dataset with the module if the model has a dataset" do
+    @c.instance_eval{dataset_module{def return_3() 3 end}}
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should add methods defined in the module to the class" do
+    @c.instance_eval{dataset_module{def return_3() 3 end}}
+    @c.return_3.should == 3
+  end
+
+  it "should cache calls and readd methods if set_dataset is used" do
+    @c.instance_eval{dataset_module{def return_3() 3 end}}
+    @c.set_dataset :items
+    @c.return_3.should == 3
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should readd methods to subclasses, if set_dataset is used in a subclass" do
+    @c.instance_eval{dataset_module{def return_3() 3 end}}
+    c = Class.new(@c)
+    c.set_dataset :items
+    c.return_3.should == 3
+    c.dataset.return_3.should == 3
+  end
+
+  it "should only have a single dataset_module per class" do
+    @c.instance_eval{dataset_module{def return_3() 3 end}}
+    @c.instance_eval{dataset_module{def return_3() 3 + (begin; super; rescue NoMethodError; 1; end) end}}
+    @c.return_3.should == 4
+  end
+
+  it "should not have subclasses share the dataset_module" do
+    @c.instance_eval{dataset_module{def return_3() 3 end}}
+    c = Class.new(@c)
+    c.instance_eval{dataset_module{def return_3() 3 + (begin; super; rescue NoMethodError; 1; end) end}}
+    c.return_3.should == 6
+  end
+end
+
 describe "A model class with implicit table name" do
   before do
     class Donkey < Sequel::Model
@@ -258,7 +302,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
   before do
     @c = Class.new(Sequel::Model(:blahblah)) do
       columns :x, :y, :z
-      def _refresh(ds)
+      def _save_refresh
         self
       end
     end
@@ -485,3 +529,49 @@ describe Sequel::Model, ".[] optimization" do
     @c[1]
   end
 end
+
+describe "Model datasets #with_pk" do
+  before do
+    @c = Class.new(Sequel::Model(:a))
+    @ds = @c.dataset
+    def @ds.fetch_rows(sql)
+      db << sql
+      yield(:id=>1)
+    end
+    @sqls = MODEL_DB.sqls
+    @sqls.clear
+  end
+
+  it "should return the first record where the primary key matches" do
+    @ds.with_pk(1).should == @c.load(:id=>1)
+    @sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+  end
+
+  it "should handle existing filters" do
+    @ds.filter(:a=>2).with_pk(1)
+    @sqls.should == ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
+  end
+
+  it "should work with string values" do
+    @ds.with_pk("foo")
+    @sqls.should == ["SELECT * FROM a WHERE (a.id = 'foo') LIMIT 1"]
+  end
+
+  it "should handle an array for composite primary keys" do
+    @c.set_primary_key :id1, :id2
+    @ds.with_pk([1, 2])
+    ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
+    "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].should include(@sqls.first)
+    @sqls.length.should == 1
+  end
+
+  it "should have #[] consider an integer as a primary key lookup" do
+    @ds[1].should == @c.load(:id=>1)
+    @sqls.should == ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+  end
+
+  it "should not have #[] consider a string as a primary key lookup" do
+    @ds['foo'].should == @c.load(:id=>1)
+    @sqls.should == ["SELECT * FROM a WHERE (foo) LIMIT 1"]
+  end
+end