sequel 3.21.0 → 3.24.0

data/spec/extensions/serialization_modification_detection_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "serialization_modification_detection plugin" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.class_eval do
+      columns :id, :h
+      plugin :serialization, :yaml, :h
+      plugin :serialization_modification_detection
+    end
+    @o1 = @c.new
+    @o2 = @c.load(:id=>1, :h=>"--- {}\n\n")
+    MODEL_DB.reset
+  end
+  
+  it "should not detect columns that haven't been changed" do
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.h.clear
+    @o2.changed_columns.should == []
+  end
+  
+  it "should detect columns that have been changed" do
+    @o2.changed_columns.should == []
+    @o2.h.should == {}
+    @o2.h[1] = 2
+    @o2.changed_columns.should == [:h]
+  end
+  
+  it "should report correct changed_columns after saving" do
+    @o2.h[1] = 2
+    @o2.save_changes
+    @o2.changed_columns.should == []
+  end
+end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -54,6 +54,17 @@ describe Sequel::Model, "#sti_key" do
     StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
   end 
 
+  it "should return rows with the correct class for subclasses based on the polymorphic_key value" do
+    class ::StiTestSub1Sub < StiTestSub1
+    end 
+    ds = StiTestSub1.dataset
+    def ds.fetch_rows(sql)
+      yield({:kind=>'StiTestSub1'})
+      yield({:kind=>'StiTestSub1Sub'})
+    end 
+    StiTestSub1.all.collect{|x| x.class}.should == [StiTestSub1, StiTestSub1Sub]
+  end 
+
   it "should fallback to the main class if the given class does not exist" do
     def @ds.fetch_rows(sql)
       yield({:kind=>'StiTestSub3'})

data/spec/extensions/spec_helper.rb

@@ -8,9 +8,11 @@ unless Sequel.const_defined?('Model')
   require 'sequel/model'
 end
 
-Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot')
+Sequel.extension(*%w'string_date_time inflector pagination query pretty_table blank migration schema_dumper looser_typecasting sql_expr thread_local_timezones to_dot columns_introspection')
 {:hook_class_methods=>[], :schema=>[], :validation_class_methods=>[]}.each{|p, opts| Sequel::Model.plugin(p, *opts)}
 
+Sequel::Dataset.introspect_all_columns if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+
 def skip_warn(s)
   warn "Skipping test of #{s}" if ENV["SKIPPED_TEST_WARN"]
 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/extensions/xml_serializer_spec.rb

@@ -36,6 +36,18 @@ describe "Sequel::Plugins::XmlSerializer" do
     Album.from_xml(@album.to_xml).should == @album
   end
 
+  it "should round trip successfully for namespaced models" do
+    module XmlSerializerTest
+      class Artist < Sequel::Model
+      plugin :xml_serializer
+      columns :id, :name
+      @db_schema = {:id=>{:type=>:integer}, :name=>{:type=>:string}}
+      end 
+    end
+    artist = XmlSerializerTest::Artist.load(:id=>2, :name=>'YJM')
+    XmlSerializerTest::Artist.from_xml(artist.to_xml).should == artist
+  end
+
   it "should round trip successfully with empty strings" do
     artist = Artist.load(:id=>2, :name=>'')
     Artist.from_xml(artist.to_xml).should == artist

data/spec/integration/associations_test.rb

@@ -22,6 +22,172 @@ shared_examples_for "regular and composite key associations" do
     @tag.albums.should == [@album]
   end
   
+  specify "should work correctly with prepared_statements_association plugin" do
+    @album.update(:artist => @artist)
+    @album.add_tag(@tag)
+    
+    @album.reload
+    @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]
+    Tag.filter(:albums=>@album).all.should == [@tag]
+    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)
@@ -151,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)
@@ -216,6 +384,48 @@ describe "Sequel::Model Simple Associations" do
     @tag.reload.albums.should == []
   end
   
+  specify "should handle dynamic callbacks for regular loading" do
+    @artist.add_album(@album)
+
+    @artist.albums.should == [@album]
+    @artist.albums(proc{|ds| ds.exclude(:id=>@album.id)}).should == []
+    @artist.albums(proc{|ds| ds.filter(:id=>@album.id)}).should == [@album]
+
+    @album.artist.should == @artist
+    @album.artist(proc{|ds| ds.exclude(:id=>@artist.id)}).should == nil
+    @album.artist(proc{|ds| ds.filter(:id=>@artist.id)}).should == @artist
+
+    if RUBY_VERSION >= '1.8.7'
+      @artist.albums{|ds| ds.exclude(:id=>@album.id)}.should == []
+      @artist.albums{|ds| ds.filter(:id=>@album.id)}.should == [@album]
+      @album.artist{|ds| ds.exclude(:id=>@artist.id)}.should == nil
+      @album.artist{|ds| ds.filter(:id=>@artist.id)}.should == @artist
+    end
+  end
+  
+  specify "should handle dynamic callbacks for eager loading via eager and eager_graph" do
+    @artist.add_album(@album)
+    @album.add_tag(@tag)
+    album2 = @artist.add_album(:name=>'Foo')
+    tag2 = album2.add_tag(:name=>'T2')
+
+    artist = Artist.eager(:albums=>:tags).all.first
+    artist.albums.should == [@album, album2]
+    artist.albums.map{|x| x.tags}.should == [[@tag], [tag2]]
+
+    artist = Artist.eager_graph(:albums=>:tags).all.first
+    artist.albums.should == [@album, album2]
+    artist.albums.map{|x| x.tags}.should == [[@tag], [tag2]]
+
+    artist = Artist.eager(:albums=>{proc{|ds| ds.where(:id=>album2.id)}=>:tags}).all.first
+    artist.albums.should == [album2]
+    artist.albums.first.tags.should == [tag2]
+
+    artist = Artist.eager_graph(:albums=>{proc{|ds| ds.where(:id=>album2.id)}=>:tags}).all.first
+    artist.albums.should == [album2]
+    artist.albums.first.tags.should == [tag2]
+  end
+  
   specify "should have remove method raise an error for one_to_many records if the object isn't already associated" do
     proc{@artist.remove_album(@album.id)}.should raise_error(Sequel::Error)
     proc{@artist.remove_album(@album)}.should raise_error(Sequel::Error)
@@ -275,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'
@@ -205,6 +211,25 @@ describe "Many Through Many Plugin" do
     Artist.filter(:artists__id=>2).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'A C'
     Artist.filter(:artists__id=>3).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B C'
     Artist.filter(:artists__id=>4).eager_graph(:albums).all.map{|x| x.albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+
+    Artist.filter(:albums=>@album1).all.map{|a| a.name}.sort.should == %w'1 2'
+    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
@@ -214,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'
@@ -223,6 +254,22 @@ describe "Many Through Many Plugin" do
     Artist.filter(:artists__id=>2).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 3'
     Artist.filter(:artists__id=>3).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'2 3 4'
     Artist.filter(:artists__id=>4).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 3 4'
+
+    Artist.filter(:related_artists=>@artist1).all.map{|a| a.name}.sort.should == %w'1 2 4'
+    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
@@ -241,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'
@@ -250,6 +303,25 @@ describe "Many Through Many Plugin" do
     Artist.filter(:artists__id=>2).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C D'
     Artist.filter(:artists__id=>3).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B D'
     Artist.filter(:artists__id=>4).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+
+    Artist.filter(:related_albums=>@album1).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    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
 
@@ -1306,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