sequel 3.23.0 → 3.24.0

data/spec/extensions/prepared_statements_with_pk_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "prepared_statements_with_pk plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:people))
+    @c.columns :id, :name, :i
+    @ds = ds = @c.dataset
+    def ds.fetch_rows(sql)
+      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
+      super{|h|}
+      yield(:id=>1, :name=>'foo', :i=>2)
+    end
+    @c.plugin :prepared_statements_with_pk
+    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
+    @c.db.execute 'foo'
+    @sqls = @c.db.sqls
+    @sqls.clear
+  end
+
+  specify "should load the prepared_statements plugin" do
+    @c.plugins.should include(Sequel::Plugins::PreparedStatements)
+  end
+
+  specify "should correctly lookup by primary key from dataset" do
+    @c.dataset.filter(:name=>'foo')[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((name = 'foo') AND (id = 1)) LIMIT 1"]
+  end
+
+  specify "should still work correctly if there are multiple conflicting variables" do
+    @c.dataset.filter(:name=>'foo').or(:name=>'bar')[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (id = 1)) LIMIT 1"]
+  end
+
+  specify "should still work correctly if the primary key is used elsewhere in the query" do
+    @c.dataset.filter{id > 2}[1].should == @p
+    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((id > 2) AND (id = 1)) LIMIT 1"]
+  end
+end

data/spec/extensions/to_dot_spec.rb

@@ -2,9 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "to_dot extension" do
   def dot(ds)
-    a = []
-    ds.send(:_to_dot, a, "", 0, ds, 0)
-    a[2..-1]
+    Sequel::ToDot.new(ds).instance_variable_get(:@dot)[4...-1]
   end
 
   before do
@@ -123,7 +121,7 @@ END
   end
 
   it "should handle SQL::Subscript" do
-    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript: a\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
+    dot(@ds.select(:a.sql_subscript(1))).should == ["1 -> 2 [label=\"select\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\"Subscript\"];", "3 -> 4 [label=\"f\"];", "4 [label=\":a\"];", "3 -> 5 [label=\"sub\"];", "5 [label=\"Array\"];", "5 -> 6 [label=\"0\"];", "6 [label=\"1\"];"]
   end
 
   it "should handle SQL::WindowFunction" do
@@ -135,7 +133,7 @@ END
   end
 
   it "should handle JOIN ON" do
-    dot(@ds.from(:a).join(:d, :b=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"Array\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"Array\"];", "8 -> 9 [label=\"0\"];", "9 [label=\"QualifiedIdentifier\"];", "9 -> 10 [label=\"table\"];", "10 [label=\"\\\"d\\\"\"];", "9 -> 11 [label=\"column\"];", "11 [label=\"\\\"b\\\"\"];", "8 -> 12 [label=\"1\"];", "12 [label=\"QualifiedIdentifier\"];", "12 -> 13 [label=\"table\"];", "13 [label=\"\\\"a\\\"\"];", "12 -> 14 [label=\"column\"];", "14 [label=\"\\\"c\\\"\"];"]
+    dot(@ds.from(:a).join(:d, :b=>:c)).should == ["1 -> 2 [label=\"from\"];", "2 [label=\"Array\"];", "2 -> 3 [label=\"0\"];", "3 [label=\":a\"];", "1 -> 4 [label=\"join\"];", "4 [label=\"Array\"];", "4 -> 5 [label=\"0\"];", "5 [label=\"INNER JOIN ON\"];", "5 -> 6 [label=\"table\"];", "6 [label=\":d\"];", "5 -> 7 [label=\"on\"];", "7 [label=\"ComplexExpression: =\"];", "7 -> 8 [label=\"0\"];", "8 [label=\"QualifiedIdentifier\"];", "8 -> 9 [label=\"table\"];", "9 [label=\"\\\"d\\\"\"];", "8 -> 10 [label=\"column\"];", "10 [label=\"\\\"b\\\"\"];", "7 -> 11 [label=\"1\"];", "11 [label=\"QualifiedIdentifier\"];", "11 -> 12 [label=\"table\"];", "12 [label=\"\\\"a\\\"\"];", "11 -> 13 [label=\"column\"];", "13 [label=\"\\\"c\\\"\"];"]
   end
 
   it "should handle JOIN USING" do

data/spec/integration/associations_test.rb

@@ -22,7 +22,7 @@ shared_examples_for "regular and composite key associations" do
     @tag.albums.should == [@album]
   end
   
-  specify "should work correctly when filtering by associations" do
+  specify "should work correctly with prepared_statements_association plugin" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
@@ -30,6 +30,17 @@ shared_examples_for "regular and composite key associations" do
     @artist.reload
     @tag.reload
     
+    [Tag, Album, Artist].each{|x| x.plugin :prepared_statements_associations}
+    @album.artist.should == @artist
+    @artist.albums.should == [@album]
+    @album.tags.should == [@tag]
+    @tag.albums.should == [@album]
+  end
+
+  specify "should work correctly when filtering by associations" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
     Artist.filter(:albums=>@album).all.should == [@artist]
     Album.filter(:artist=>@artist).all.should == [@album]
     Album.filter(:tags=>@tag).all.should == [@album]
@@ -37,7 +48,146 @@ shared_examples_for "regular and composite key associations" do
     Album.filter(:artist=>@artist, :tags=>@tag).all.should == [@album]
     @artist.albums_dataset.filter(:tags=>@tag).all.should == [@album]
   end
+
+  specify "should work correctly when excluding by associations" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    album, artist, tag = @pr.call
+
+    Artist.exclude(:albums=>@album).all.should == [artist]
+    Album.exclude(:artist=>@artist).all.should == [album]
+    Album.exclude(:tags=>@tag).all.should == [album]
+    Tag.exclude(:albums=>@album).all.should == [tag]
+    Album.exclude(:artist=>@artist, :tags=>@tag).all.should == [album]
+  end
+  
+  specify "should work correctly when filtering by multiple associations" do
+    album, artist, tag = @pr.call
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    Artist.filter(:albums=>[@album, album]).all.should == [@artist]
+    Album.filter(:artist=>[@artist, artist]).all.should == [@album]
+    Album.filter(:tags=>[@tag, tag]).all.should == [@album]
+    Tag.filter(:albums=>[@album, album]).all.should == [@tag]
+    Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == [@album]
+    @artist.albums_dataset.filter(:tags=>[@tag, tag]).all.should == [@album]
+
+    album.add_tag(tag)
+
+    Artist.filter(:albums=>[@album, album]).all.should == [@artist]
+    Album.filter(:artist=>[@artist, artist]).all.should == [@album]
+    Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+    Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
+    Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == [@album]
+
+    album.update(:artist => artist)
+
+    Artist.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Album.filter(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
+    Album.filter(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+    Tag.filter(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
+    Album.filter(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+  end
+
+  specify "should work correctly when excluding by multiple associations" do
+    album, artist, tag = @pr.call
+
+    Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [@album, album]
+    Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+    Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [@tag, tag]
+    Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [@album, album]
+
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+
+    Artist.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [artist]
+    Album.exclude(:artist=>[@artist, artist]).all.sort_by{|x| x.pk}.should == [album]
+    Album.exclude(:tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [album]
+    Tag.exclude(:albums=>[@album, album]).all.sort_by{|x| x.pk}.should == [tag]
+    Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.sort_by{|x| x.pk}.should == [album]
+
+    album.add_tag(tag)
+
+    Artist.exclude(:albums=>[@album, album]).all.should == [artist]
+    Album.exclude(:artist=>[@artist, artist]).all.should == [album]
+    Album.exclude(:tags=>[@tag, tag]).all.should == []
+    Tag.exclude(:albums=>[@album, album]).all.should == []
+    Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == [album]
+
+    album.update(:artist => artist)
+
+    Artist.exclude(:albums=>[@album, album]).all.should == []
+    Album.exclude(:artist=>[@artist, artist]).all.should == []
+    Album.exclude(:tags=>[@tag, tag]).all.should == []
+    Tag.exclude(:albums=>[@album, album]).all.should == []
+    Album.exclude(:artist=>[@artist, artist], :tags=>[@tag, tag]).all.should == []
+  end
   
+  specify "should work correctly when excluding by associations in regards to NULL values" do
+    Artist.exclude(:albums=>@album).all.should == [@artist]
+    Album.exclude(:artist=>@artist).all.should == [@album]
+    Album.exclude(:tags=>@tag).all.should == [@album]
+    Tag.exclude(:albums=>@album).all.should == [@tag]
+    Album.exclude(:artist=>@artist, :tags=>@tag).all.should == [@album]
+
+    @album.update(:artist => @artist)
+    @artist.albums_dataset.exclude(:tags=>@tag).all.should == [@album]
+  end
+
+  specify "should handle NULL values in join table correctly when filtering/excluding many_to_many associations" do
+    @ins.call
+    Album.exclude(:tags=>@tag).all.should == [@album]
+    @album.add_tag(@tag)
+    Album.filter(:tags=>@tag).all.should == [@album]
+    album, artist, tag = @pr.call
+    Album.exclude(:tags=>@tag).all.should == [album]
+    Album.exclude(:tags=>tag).all.sort_by{|x| x.pk}.should == [@album, album]
+  end
+
+  specify "should work correctly when filtering by association datasets" do
+    album, artist, tag = @pr.call
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    album.add_tag(tag)
+    album.update(:artist => artist)
+
+    Artist.filter(:albums=>Album.dataset).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Artist.filter(:albums=>Album.dataset.filter(Array(Album.primary_key).zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [artist]
+    Artist.filter(:albums=>Album.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+    Album.filter(:artist=>Artist.dataset).all.sort_by{|x| x.pk}.should == [@album, album]
+    Album.filter(:artist=>Artist.dataset.filter(Array(Artist.primary_key).zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [album]
+    Album.filter(:artist=>Artist.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+    Album.filter(:tags=>Tag.dataset).all.sort_by{|x| x.pk}.should == [@album, album]
+    Album.filter(:tags=>Tag.dataset.filter(Array(Tag.primary_key).zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [album]
+    Album.filter(:tags=>Tag.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+    Tag.filter(:albums=>Album.dataset).all.sort_by{|x| x.pk}.should == [@tag, tag]
+    Tag.filter(:albums=>Album.dataset.filter(Array(Album.primary_key).zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [tag]
+    Tag.filter(:albums=>Album.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == []
+  end
+
+  specify "should work correctly when excluding by association datasets" do
+    album, artist, tag = @pr.call
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    album.add_tag(tag)
+    album.update(:artist => artist)
+
+    Artist.exclude(:albums=>Album.dataset).all.sort_by{|x| x.pk}.should == []
+    Artist.exclude(:albums=>Album.dataset.filter(Array(Album.primary_key).zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@artist]
+    Artist.exclude(:albums=>Album.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@artist, artist]
+    Album.exclude(:artist=>Artist.dataset).all.sort_by{|x| x.pk}.should == []
+    Album.exclude(:artist=>Artist.dataset.filter(Array(Artist.primary_key).zip(Array(artist.pk)))).all.sort_by{|x| x.pk}.should == [@album]
+    Album.exclude(:artist=>Artist.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
+    Album.exclude(:tags=>Tag.dataset).all.sort_by{|x| x.pk}.should == []
+    Album.exclude(:tags=>Tag.dataset.filter(Array(Tag.primary_key).zip(Array(tag.pk)))).all.sort_by{|x| x.pk}.should == [@album]
+    Album.exclude(:tags=>Tag.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@album, album]
+    Tag.exclude(:albums=>Album.dataset).all.sort_by{|x| x.pk}.should == []
+    Tag.exclude(:albums=>Album.dataset.filter(Array(Album.primary_key).zip(Array(album.pk)))).all.sort_by{|x| x.pk}.should == [@tag]
+    Tag.exclude(:albums=>Album.dataset.filter(1=>0)).all.sort_by{|x| x.pk}.should == [@tag, tag]
+  end
+
   specify "should have remove methods work" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
@@ -167,6 +317,8 @@ describe "Sequel::Model Simple Associations" do
     @album = Album.create(:name=>'Al')
     @artist = Artist.create(:name=>'Ar')
     @tag = Tag.create(:name=>'T')
+    @pr = lambda{[Album.create(:name=>'Al2'),Artist.create(:name=>'Ar2'),Tag.create(:name=>'T2')]}
+    @ins = lambda{@db[:albums_tags].insert(:tag_id=>@tag.id)}
   end
   after do
     @db.drop_table(:albums_tags, :tags, :albums, :artists)
@@ -333,6 +485,8 @@ describe "Sequel::Model Composite Key Associations" do
     @album = Album.create(:name=>'Al', :id1=>1, :id2=>2)
     @artist = Artist.create(:name=>'Ar', :id1=>3, :id2=>4)
     @tag = Tag.create(:name=>'T', :id1=>5, :id2=>6)
+    @pr = lambda{[Album.create(:name=>'Al2', :id1=>11, :id2=>12),Artist.create(:name=>'Ar2', :id1=>13, :id2=>14),Tag.create(:name=>'T2', :id1=>15, :id2=>16)]}
+    @ins = lambda{@db[:albums_tags].insert(:tag_id1=>@tag.id1, :tag_id2=>@tag.id2)}
   end
   after do
     @db.drop_table(:albums_tags, :tags, :albums, :artists)

data/spec/integration/dataset_test.rb

@@ -86,6 +86,13 @@ describe "Simple Dataset operations" do
   specify "should alias columns correctly" do
     @ds.select(:id___x, :number___n).first.should == {:x=>1, :n=>10}
   end
+
+  specify "should handle true/false properly" do
+    @ds.filter(Sequel::TRUE).select_map(:number).should == [10]
+    @ds.filter(Sequel::FALSE).select_map(:number).should == []
+    @ds.filter(true).select_map(:number).should == [10]
+    @ds.filter(false).select_map(:number).should == []
+  end
 end
 
 describe Sequel::Dataset do
@@ -471,7 +478,7 @@ describe Sequel::SQL::Constants do
     @c2 = proc{|v| v.is_a?(Date) ? v : Date.parse(v) }
   end
   after do
-    @db.drop_table(:constants)
+    @db.drop_table(:constants) if @db.table_exists?(:constants)
   end
   
   cspecify "should have working CURRENT_DATE", [:odbc, :mssql], [:jdbc, :sqlite] do

data/spec/integration/plugin_test.rb

@@ -196,6 +196,12 @@ describe "Many Through Many Plugin" do
     Artist[3].albums.map{|x| x.name}.sort.should == %w'B C'
     Artist[4].albums.map{|x| x.name}.sort.should == %w'B D'
     
+    Artist.plugin :prepared_statements_associations
+    Artist[1].albums.map{|x| x.name}.sort.should == %w'A D'
+    Artist[2].albums.map{|x| x.name}.sort.should == %w'A C'
+    Artist[3].albums.map{|x| x.name}.sort.should == %w'B C'
+    Artist[4].albums.map{|x| x.name}.sort.should == %w'B D'
+
     Artist.filter(:id=>1).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A D'
     Artist.filter(:id=>2).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A C'
     Artist.filter(:id=>3).eager(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B C'
@@ -210,6 +216,20 @@ describe "Many Through Many Plugin" do
     Artist.filter(:albums=>@album2).all.map{|a| a.name}.sort.should == %w'3 4'
     Artist.filter(:albums=>@album3).all.map{|a| a.name}.sort.should == %w'2 3'
     Artist.filter(:albums=>@album4).all.map{|a| a.name}.sort.should == %w'1 4'
+
+    Artist.exclude(:albums=>@album1).all.map{|a| a.name}.sort.should == %w'3 4'
+    Artist.exclude(:albums=>@album2).all.map{|a| a.name}.sort.should == %w'1 2'
+    Artist.exclude(:albums=>@album3).all.map{|a| a.name}.sort.should == %w'1 4'
+    Artist.exclude(:albums=>@album4).all.map{|a| a.name}.sort.should == %w'2 3'
+
+    Artist.filter(:albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    Artist.filter(:albums=>[@album2, @album4]).all.map{|a| a.name}.sort.should == %w'1 3 4'
+
+    Artist.exclude(:albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'4'
+    Artist.exclude(:albums=>[@album2, @album4]).all.map{|a| a.name}.sort.should == %w'2'
+
+    Artist.filter(:albums=>Album.filter(:id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    Artist.exclude(:albums=>Album.filter(:id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'4'
   end
 
   specify "should handle typical case with 3 join tables" do
@@ -219,6 +239,12 @@ describe "Many Through Many Plugin" do
     Artist[3].related_artists.map{|x| x.name}.sort.should == %w'2 3 4'
     Artist[4].related_artists.map{|x| x.name}.sort.should == %w'1 3 4'
     
+    Artist.plugin :prepared_statements_associations
+    Artist[1].related_artists.map{|x| x.name}.sort.should == %w'1 2 4'
+    Artist[2].related_artists.map{|x| x.name}.sort.should == %w'1 2 3'
+    Artist[3].related_artists.map{|x| x.name}.sort.should == %w'2 3 4'
+    Artist[4].related_artists.map{|x| x.name}.sort.should == %w'1 3 4'
+    
     Artist.filter(:id=>1).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 4'
     Artist.filter(:id=>2).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 3'
     Artist.filter(:id=>3).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'2 3 4'
@@ -233,6 +259,17 @@ describe "Many Through Many Plugin" do
     Artist.filter(:related_artists=>@artist2).all.map{|a| a.name}.sort.should == %w'1 2 3'
     Artist.filter(:related_artists=>@artist3).all.map{|a| a.name}.sort.should == %w'2 3 4'
     Artist.filter(:related_artists=>@artist4).all.map{|a| a.name}.sort.should == %w'1 3 4'
+
+    Artist.exclude(:related_artists=>@artist1).all.map{|a| a.name}.sort.should == %w'3'
+    Artist.exclude(:related_artists=>@artist2).all.map{|a| a.name}.sort.should == %w'4'
+    Artist.exclude(:related_artists=>@artist3).all.map{|a| a.name}.sort.should == %w'1'
+    Artist.exclude(:related_artists=>@artist4).all.map{|a| a.name}.sort.should == %w'2'
+
+    Artist.filter(:related_artists=>[@artist1, @artist4]).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
+    Artist.exclude(:related_artists=>[@artist1, @artist4]).all.map{|a| a.name}.sort.should == %w''
+
+    Artist.filter(:related_artists=>Artist.filter(:id=>@artist1.id)).all.map{|a| a.name}.sort.should == %w'1 2 4'
+    Artist.exclude(:related_artists=>Artist.filter(:id=>@artist1.id)).all.map{|a| a.name}.sort.should == %w'3'
   end
 
   specify "should handle extreme case with 5 join tables" do
@@ -251,6 +288,12 @@ describe "Many Through Many Plugin" do
     Artist[3].related_albums.map{|x| x.name}.sort.should == %w'A B D'
     Artist[4].related_albums.map{|x| x.name}.sort.should == %w'B D'
     
+    Artist.plugin :prepared_statements_associations
+    Artist[1].related_albums.map{|x| x.name}.sort.should == %w'A B C'
+    Artist[2].related_albums.map{|x| x.name}.sort.should == %w'A B C D'
+    Artist[3].related_albums.map{|x| x.name}.sort.should == %w'A B D'
+    Artist[4].related_albums.map{|x| x.name}.sort.should == %w'B D'
+    
     Artist.filter(:id=>1).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C'
     Artist.filter(:id=>2).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C D'
     Artist.filter(:id=>3).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B D'
@@ -265,6 +308,20 @@ describe "Many Through Many Plugin" do
     Artist.filter(:related_albums=>@album2).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
     Artist.filter(:related_albums=>@album3).all.map{|a| a.name}.sort.should == %w'1 2'
     Artist.filter(:related_albums=>@album4).all.map{|a| a.name}.sort.should == %w'2 3 4'
+
+    Artist.exclude(:related_albums=>@album1).all.map{|a| a.name}.sort.should == %w'4'
+    Artist.exclude(:related_albums=>@album2).all.map{|a| a.name}.sort.should == %w''
+    Artist.exclude(:related_albums=>@album3).all.map{|a| a.name}.sort.should == %w'3 4'
+    Artist.exclude(:related_albums=>@album4).all.map{|a| a.name}.sort.should == %w'1'
+
+    Artist.filter(:related_albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    Artist.filter(:related_albums=>[@album3, @album4]).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
+
+    Artist.exclude(:related_albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'4'
+    Artist.exclude(:related_albums=>[@album2, @album4]).all.map{|a| a.name}.sort.should == %w''
+
+    Artist.filter(:related_albums=>Album.filter(:id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    Artist.exclude(:related_albums=>Album.filter(:id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'4'
   end
 end
 
@@ -1321,3 +1378,65 @@ describe "Sequel::Plugins::Tree" do
     end
   end
 end
+
+describe "Sequel::Plugins::PreparedStatements" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:ps_test) do
+      primary_key :id
+      String :name
+      Integer :i
+    end
+    @c = Class.new(Sequel::Model(@db[:ps_test]))
+    @foo = @c.create(:name=>'foo', :i=>10)
+    @bar = @c.create(:name=>'bar', :i=>20)
+    @c.plugin :prepared_statements_with_pk
+  end
+  after do
+    @db.drop_table(:ps_test)
+  end
+
+  it "should work with looking up using Model.[]" do 
+    @c[@foo.id].should == @foo
+    @c[@bar.id].should == @bar
+    @c[0].should == nil
+  end
+
+  it "should work with looking up using Dataset#with_pk" do 
+    @c.dataset.with_pk(@foo.id).should == @foo
+    @c.dataset.with_pk(@bar.id).should == @bar
+    @c.dataset.with_pk(0).should == nil
+
+    @c.dataset.filter(:i=>0).with_pk(@foo.id).should == nil
+    @c.dataset.filter(:i=>10).with_pk(@foo.id).should == @foo
+    @c.dataset.filter(:i=>20).with_pk(@bar.id).should == @bar
+    @c.dataset.filter(:name=>'foo').with_pk(@foo.id).should == @foo
+    @c.dataset.filter(:name=>'bar').with_pk(@bar.id).should == @bar
+    @c.dataset.filter(:name=>'baz').with_pk(@bar.id).should == nil
+  end
+
+  it "should work with Model#destroy" do 
+    @foo.destroy
+    @bar.destroy
+    @c[@foo.id].should == nil
+    @c[@bar.id].should == nil
+  end
+
+  it "should work with Model#update" do 
+    @foo.update(:name=>'foo2', :i=>30)
+    @c[@foo.id].should == @c.load(:id=>@foo.id, :name=>'foo2', :i=>30)
+    @foo.update(:name=>'foo3')
+    @c[@foo.id].should == @c.load(:id=>@foo.id, :name=>'foo3', :i=>30)
+    @foo.update(:i=>40)
+    @c[@foo.id].should == @c.load(:id=>@foo.id, :name=>'foo3', :i=>40)
+  end
+
+  it "should work with Model#create" do 
+    o = @c.create(:name=>'foo2', :i=>30)
+    @c[o.id].should == @c.load(:id=>o.id, :name=>'foo2', :i=>30)
+    o = @c.create(:name=>'foo2')
+    @c[o.id].should == @c.load(:id=>o.id, :name=>'foo2', :i=>nil)
+    o = @c.create(:i=>30)
+    @c[o.id].should == @c.load(:id=>o.id, :name=>nil, :i=>30)
+  end
+end

data/spec/integration/prepared_statement_test.rb

@@ -251,7 +251,7 @@ describe "Bound Argument Types" do
     @ds.filter(:t=>@ds.ba(:$x, :timestamp)).prepare(:first, :ps_time).call(:x=>@vs[:t])[:t].should == @vs[:t]
   end
 
-  cspecify "should handle blob type", [:swift] do
+  cspecify "should handle blob type", [:swift], [:odbc] do
     @ds.filter(:file=>@ds.ba(:$x, :bytea)).prepare(:first, :ps_blob).call(:x=>@vs[:file])[:file].should == @vs[:file]
   end
 
@@ -268,3 +268,74 @@ describe "Bound Argument Types" do
   end
 end unless INTEGRATION_DB.adapter_scheme == :swift && INTEGRATION_DB.database_type == :postgres
 
+describe "Dataset#unbind" do
+  before do
+    @ds = ds = INTEGRATION_DB[:items]
+    @ct = proc do |t, v|
+      INTEGRATION_DB.create_table!(:items) do
+        column :c, t
+      end
+      ds.insert(:c=>v)
+    end
+    @u = proc{|ds| ds, bv = ds.unbind; ds.call(:first, bv)}
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items) rescue nil
+  end
+  
+  specify "should unbind values assigned to equality and inequality statements" do
+    @ct[Integer, 10]
+    @u[@ds.filter(:c=>10)].should == {:c=>10}
+    @u[@ds.exclude(:c=>10)].should == nil
+    @u[@ds.filter{c < 10}].should == nil
+    @u[@ds.filter{c <= 10}].should == {:c=>10}
+    @u[@ds.filter{c > 10}].should == nil
+    @u[@ds.filter{c >= 10}].should == {:c=>10}
+  end
+
+  cspecify "should handle numerics and strings", [:odbc], [:swift, :sqlite] do
+    @ct[Integer, 10]
+    @u[@ds.filter(:c=>10)].should == {:c=>10}
+    @ct[Float, 0.0]
+    @u[@ds.filter{c < 1}].should == {:c=>0.0}
+    @ct[String, 'foo']
+    @u[@ds.filter(:c=>'foo')].should == {:c=>'foo'}
+
+    INTEGRATION_DB.create_table!(:items) do
+      BigDecimal :c, :size=>[15,2]
+    end
+    @ds.insert(:c=>BigDecimal.new('1.1'))
+    @u[@ds.filter{c > 0}].should == {:c=>BigDecimal.new('1.1')}
+  end
+
+  cspecify "should handle dates and times", [:sqlite], [:do], [:jdbc, :mssql], [:tinytds] do
+    @ct[Date, Date.today]
+    @u[@ds.filter(:c=>Date.today)].should == {:c=>Date.today}
+    t = Time.now
+    @ct[Time, t]
+    @u[@ds.filter{c < t + 1}][:c].to_i.should == t.to_i
+  end
+
+  specify "should handle QualifiedIdentifiers" do
+    @ct[Integer, 10]
+    @u[@ds.filter{items__c > 1}].should == {:c=>10}
+  end
+
+  specify "should handle deep nesting" do
+    INTEGRATION_DB.create_table!(:items) do
+      Integer :a
+      Integer :b
+      Integer :c
+      Integer :d
+    end
+    @ds.insert(:a=>2, :b=>0, :c=>3, :d=>5)
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and({~{:d=>4}=>1}.case(0) => 1)].should == {:a=>2, :b=>0, :c=>3, :d=>5}
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and({~{:d=>5}=>1}.case(0) => 1)].should == nil
+  end
+
+  specify "should handle case where the same variable has the same value in multiple places " do
+    @ct[Integer, 1]
+    @u[@ds.filter{c > 1}.or{c < 1}.invert].should == {:c=>1}
+    @u[@ds.filter{c > 1}.or{c < 1}].should == nil
+  end
+end