sequel 3.23.0 → 3.24.0

data/spec/integration/schema_test.rb

@@ -174,6 +174,15 @@ describe "Database schema modifiers" do
     @db.create_table!(:items, :temp=>true){Integer :number}
   end
   
+  specify "should have create_table? only create the table if it doesn't already exist" do
+    @db.create_table!(:items){String :a}
+    @db.create_table?(:items){String :b}
+    @db[:items].columns.should == [:a]
+    @db.drop_table(:items) rescue nil
+    @db.create_table?(:items){String :b}
+    @db[:items].columns.should == [:b]
+  end
+
   specify "should rename tables correctly" do
     @db.drop_table(:items) rescue nil
     @db.create_table!(:items2){Integer :number}
@@ -362,25 +371,74 @@ describe "Database#tables" do
         "xxxxx#{@@xxxxx += 1}"
       end
     end
-    @iom = INTEGRATION_DB.identifier_output_method
-    @iim = INTEGRATION_DB.identifier_input_method
+    @db = INTEGRATION_DB
+    @db.create_table(:sequel_test_table){Integer :a}
+    @db.create_view :sequel_test_view, @db[:sequel_test_table]
+    @iom = @db.identifier_output_method
+    @iim = @db.identifier_input_method
     clear_sqls
   end
   after do
-    INTEGRATION_DB.identifier_output_method = @iom
-    INTEGRATION_DB.identifier_input_method = @iim
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
+    @db.identifier_output_method = @iom
+    @db.identifier_input_method = @iim
+  end
+
+  specify "should return an array of symbols" do
+    ts = @db.tables
+    ts.should be_a_kind_of(Array)
+    ts.each{|t| t.should be_a_kind_of(Symbol)}
+    ts.should include(:sequel_test_table)
+    ts.should_not include(:sequel_test_view)
+  end
+
+  specify "should respect the database's identifier_output_method" do
+    @db.identifier_output_method = :xxxxx
+    @db.identifier_input_method = :xxxxx
+    @db.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+  end
+end
+end
+
+begin
+  INTEGRATION_DB.views
+rescue Sequel::NotImplemented
+rescue
+describe "Database#views" do
+  before do
+    class ::String
+      @@xxxxx = 0
+      def xxxxx
+        "xxxxx#{@@xxxxx += 1}"
+      end
+    end
+    @db = INTEGRATION_DB
+    @db.create_table(:sequel_test_table){Integer :a}
+    @db.create_view :sequel_test_view, @db[:sequel_test_table]
+    @iom = @db.identifier_output_method
+    @iim = @db.identifier_input_method
+    clear_sqls
+  end
+  after do
+    @db.drop_view :sequel_test_view
+    @db.drop_table :sequel_test_table
+    @db.identifier_output_method = @iom
+    @db.identifier_input_method = @iim
   end
 
   specify "should return an array of symbols" do
-    ts = INTEGRATION_DB.tables
+    ts = @db.views
     ts.should be_a_kind_of(Array)
     ts.each{|t| t.should be_a_kind_of(Symbol)}
+    ts.should_not include(:sequel_test_table)
+    ts.should include(:sequel_test_view)
   end
 
   specify "should respect the database's identifier_output_method" do
-    INTEGRATION_DB.identifier_output_method = :xxxxx
-    INTEGRATION_DB.identifier_input_method = :xxxxx
-    INTEGRATION_DB.tables.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
+    @db.identifier_output_method = :xxxxx
+    @db.identifier_input_method = :xxxxx
+    @db.views.each{|t| t.to_s.should =~ /\Ax{5}\d+\z/}
   end
 end
 end

data/spec/integration/transaction_test.rb

@@ -134,4 +134,44 @@ describe "Database transactions" do
       @d.count.should == i + 1
     end
   end
+
+if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && ![[:do, :sqlite], [:tinytds, :mssql]].include?([INTEGRATION_DB.adapter_scheme, INTEGRATION_DB.database_type]))) and RUBY_VERSION < '1.9'
+  specify "should handle Thread#kill for transactions inside threads" do
+    q = Queue.new
+    q1 = Queue.new
+    t = Thread.new do
+      @db.transaction do
+        @d << {:name => 'abc', :value => 1}
+        q1.push nil
+        q.pop
+        @d << {:name => 'def', :value => 2}
+      end
+    end
+    q1.pop
+    t.kill
+    @d.count.should == 0
+  end
+
+if INTEGRATION_DB.supports_savepoints?
+  specify "should handle Thread#kill for transactions with savepoints inside threads" do
+    q = Queue.new
+    q1 = Queue.new
+    t = Thread.new do
+      @db.transaction do
+        @d << {:name => 'abc', :value => 1}
+        @db.transaction(:savepoint=>true) do
+          @d << {:name => 'def', :value => 2}
+          q1.push nil
+          q.pop
+          @d << {:name => 'ghi', :value => 3}
+        end
+        @d << {:name => 'jkl', :value => 4}
+      end
+    end
+    q1.pop
+    t.kill
+    @d.count.should == 0
+  end
+end
+end
 end

data/spec/model/associations_spec.rb

@@ -1370,7 +1370,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
@@ -1379,7 +1379,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
@@ -2282,7 +2282,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
 
@@ -2291,7 +2291,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
 
@@ -2299,7 +2299,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
@@ -2795,7 +2795,7 @@ describe "Filtering by associations" do
   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)))'
+    @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
@@ -2811,7 +2811,7 @@ describe "Filtering by associations" do
   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))))'
+    @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
@@ -2828,16 +2828,357 @@ describe "Filtering by associations" do
   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(:mtmtags=>@Tag.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+    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