sequel 3.21.0 → 3.28.0

data/spec/integration/dataset_test.rb

@@ -2,16 +2,17 @@ require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Simple Dataset operations" do
   before do
-    INTEGRATION_DB.create_table!(:items) do
+    @db = INTEGRATION_DB
+    @db.create_table!(:items) do
       primary_key :id
       Integer :number
     end
-    @ds = INTEGRATION_DB[:items]
+    @ds = @db[:items]
     @ds.insert(:number=>10)
     clear_sqls
   end
   after do
-    INTEGRATION_DB.drop_table(:items)
+    @db.drop_table(:items)
   end
 
   specify "should support sequential primary keys" do
@@ -23,7 +24,7 @@ describe "Simple Dataset operations" do
       {:id => 3, :number=>30} ]   
   end 
 
-  cspecify "should insert with a primary key specified", :mssql do
+  cspecify "should insert with a primary key specified", :db2, :mssql do
     @ds.insert(:id=>100, :number=>20)
     @ds.count.should == 2
     @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
@@ -34,6 +35,15 @@ describe "Simple Dataset operations" do
     @ds.filter(:id=>2).first[:number].should == 20
   end
 
+  cspecify "should have insert work correctly when inserting a row with all NULL values", :db2 do
+    @db.create_table!(:items) do
+      String :name
+      Integer :number
+    end
+    proc{@ds.insert}.should_not raise_error
+    @ds.all.should == [{:name=>nil, :number=>nil}]
+  end
+
   specify "should delete correctly" do
     @ds.filter(1=>1).delete.should == 1
     @ds.count.should == 0
@@ -79,13 +89,53 @@ describe "Simple Dataset operations" do
     @ds.order(:id).limit(2, 1).all.should == [{:id=>2, :number=>20}]
   end
   
-  cspecify "should fetch correctly with a limit and offset without an order", :mssql do
+  specify "should fetch correctly with a limit and offset for different combinations of from and join tables" do
+    @db.create_table!(:items2){primary_key :id2; Integer :number2}
+    @db[:items2].insert(:number2=>10)
+    @ds.from(:items, :items2).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.from(:items___i, :items2___i2).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.cross_join(:items2).order(:id).limit(2, 0).all.should ==[{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.from(:items___i).cross_join(:items2___i2).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 0).all.should == [{:id=>1, :number=>10, :id2=>1, :number2=>10, :id3=>1, :number3=>10}]
+
+    @ds.from(:items, :items2).order(:id).limit(2, 1).all.should == []
+    @ds.from(:items___i, :items2___i2).order(:id).limit(2, 1).all.should == []
+    @ds.cross_join(:items2).order(:id).limit(2, 1).all.should == []
+    @ds.from(:items___i).cross_join(:items2___i2).order(:id).limit(2, 1).all.should == []
+    @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 1).all.should == []
+    @db.drop_table(:items2)
+  end
+  
+  cspecify "should fetch correctly with a limit and offset without an order", :db2, :mssql do
     @ds.limit(2, 1).all.should == []
   end
 
+  specify "should fetch correctly with a limit in an IN subselect" do
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2)).all.should == [{:id=>1, :number=>10}]
+    @ds.insert(:number=>20)
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(1)).all.should == [{:id=>1, :number=>10}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2)).order(:id).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+  end
+  
+  specify "should fetch correctly with a limit and offset in an IN subselect" do
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 0)).all.should == [{:id=>1, :number=>10}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 1)).all.should == []
+    @ds.insert(:number=>20)
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(1, 1)).all.should == [{:id=>2, :number=>20}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 0)).order(:id).all.should == [{:id=>1, :number=>10}, {:id=>2, :number=>20}]
+    @ds.where(:id=>@ds.select(:id).order(:id).limit(2, 1)).all.should == [{:id=>2, :number=>20}]
+  end
+  
   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
@@ -262,7 +312,7 @@ describe "Simple Dataset operations in transactions" do
     INTEGRATION_DB.drop_table(:items_insert_in_transaction)
   end
 
-  cspecify "should insert correctly with a primary key specified inside a transaction", :mssql do
+  cspecify "should insert correctly with a primary key specified inside a transaction", :db2, :mssql do
     INTEGRATION_DB.transaction do
       @ds.insert(:id=>100, :number=>20)
       @ds.count.should == 1
@@ -378,7 +428,7 @@ if INTEGRATION_DB.dataset.supports_cte?
       @db[:t].with(:t, @ds.filter(:parent_id=>nil).select(:id)).order(:id).map(:id).should == [1, 2]
     end
     
-    specify "should give correct results for recursive WITH" do
+    cspecify "should give correct results for recursive WITH", :db2 do
       ds = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>nil), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
       ds.all.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>nil, :id=>2}, {:parent_id=>1, :id=>3}, {:parent_id=>1, :id=>4}, {:parent_id=>3, :id=>5}, {:parent_id=>5, :id=>6}]
       ps = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>:$n), @ds.join(:t, :i=>:parent_id).filter(:t__i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi]).prepare(:select, :cte_sel)
@@ -394,6 +444,92 @@ if INTEGRATION_DB.dataset.supports_cte?
   end
 end
 
+if INTEGRATION_DB.dataset.supports_cte?(:update) # Assume INSERT and DELETE support as well
+  describe "Common Table Expressions in INSERT/UPDATE/DELETE" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id}
+      @ds = @db[:i1]
+      @ds2 = @ds.with(:t, @ds)
+      @ds.insert(:id=>1)
+      @ds.insert(:id=>2)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results for WITH" do
+      @ds2.insert(@db[:t])
+      @ds.select_order_map(:id).should == [1, 1, 2, 2]
+      @ds2.filter(:id=>@db[:t].select{max(id)}).update(:id=>:id+1)
+      @ds.select_order_map(:id).should == [1, 1, 3, 3]
+      @ds2.filter(:id=>@db[:t].select{max(id)}).delete
+      @ds.select_order_map(:id).should == [1, 1]
+    end
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_returning?(:insert)
+  describe "RETURNING clauses in INSERT" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id; Integer :foo}
+      @ds = @db[:i1]
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results" do
+      h = {}
+      @ds.returning(:foo).insert(1, 2){|r| h = r}
+      h.should == {:foo=>2}
+      @ds.returning(:id).insert(3, 4){|r| h = r}
+      h.should == {:id=>3}
+      @ds.returning.insert(5, 6){|r| h = r}
+      h.should == {:id=>5, :foo=>6}
+      @ds.returning(:id___foo, :foo___id).insert(7, 8){|r| h = r}
+      h.should == {:id=>8, :foo=>7}
+    end
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_returning?(:update) # Assume DELETE support as well
+  describe "RETURNING clauses in UPDATE/DELETE" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id; Integer :foo}
+      @ds = @db[:i1]
+      @ds.insert(1, 2)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results" do
+      h = []
+      @ds.returning(:foo).update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:foo=>4}]
+      h.clear
+      @ds.returning(:id).update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:id=>3}]
+      h.clear
+      @ds.returning.update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:id=>4, :foo=>16}]
+      h.clear
+      @ds.returning(:id___foo, :foo___id).update(:id=>:id+1, :foo=>:foo*2){|r| h << r}
+      h.should == [{:id=>32, :foo=>5}]
+      h.clear
+
+      @ds.returning.delete{|r| h << r}
+      h.should == [{:id=>5, :foo=>32}]
+      h.clear
+      @ds.returning.delete{|r| h << r}
+      h.should == []
+    end
+  end
+end
+
 if INTEGRATION_DB.dataset.supports_window_functions?
   describe "Window Functions" do
     before do
@@ -435,21 +571,13 @@ if INTEGRATION_DB.dataset.supports_window_functions?
     cspecify "should give correct results for aggregate window functions with frames", :mssql do
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:all){}.as(:sum)}.all.should ==
-        [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:all){}.as(:sum)}.all.should ==
         [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :frame=>:all){}.as(:sum)}.all.should ==
-        [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
         
       @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:rows){}.as(:sum)}.all.should ==
-        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
       @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:rows){}.as(:sum)}.all.should ==
         [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
-      @ds.select(:id){sum(:over, :args=>amount, :frame=>:rows){}.as(:sum)}.all.should ==
-        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
     end
   end
 end
@@ -471,7 +599,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
@@ -577,7 +705,7 @@ describe "Sequel::Dataset convenience methods" do
     @ds.group_and_count(:a___c).order(:count).all.each{|h| h[:count] = h[:count].to_i}.should == [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
   end
   
-  cspecify "#range should return the range between the maximum and minimum values", :sqlite do
+  specify "#range should return the range between the maximum and minimum values" do
     @ds = @ds.unordered
     @ds.insert(20, 10)
     @ds.insert(30, 10)
@@ -625,6 +753,23 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.filter(:a=>20).or(:b=>15).all.should == [{:a=>20, :b=>30}]
     @ds.filter(:a=>10).or(:b=>15).all.should == []
   end
+
+  it "#select_group should work correctly" do
+    @ds.unordered!
+    @ds.select_group(:a).all.should == []
+    @ds.insert(20, 30)
+    @ds.select_group(:a).all.should == [{:a=>20}]
+    @ds.select_group(:b).all.should == [{:b=>30}]
+    @ds.insert(20, 40)
+    @ds.select_group(:a).all.should == [{:a=>20}]
+    @ds.order(:b).select_group(:b).all.should == [{:b=>30}, {:b=>40}]
+  end
+
+  it "#select_group should work correctly when aliasing" do
+    @ds.unordered!
+    @ds.insert(20, 30)
+    @ds.select_group(:b___c).all.should == [{:c=>30}]
+  end
   
   it "#having should work correctly" do
     @ds.unordered!
@@ -645,6 +790,77 @@ describe "Sequel::Dataset main SQL methods" do
   end
 end
 
+describe "Sequel::Dataset convenience methods" do
+  before do
+    @db = INTEGRATION_DB
+    @db.create_table!(:a){Integer :a; Integer :b; Integer :c; Integer :d}
+    @ds = @db[:a].order(:a)
+    @ds.insert(1, 2, 3, 4)
+    @ds.insert(5, 6, 7, 8)
+  end
+  after do
+    @db.drop_table(:a)
+  end
+  
+  specify "should have working #map" do
+    @ds.map(:a).should == [1, 5]
+    @ds.map(:b).should == [2, 6]
+    @ds.map([:a, :b]).should == [[1, 2], [5, 6]]
+  end
+  
+  specify "should have working #to_hash" do
+    @ds.to_hash(:a).should == {1=>{:a=>1, :b=>2, :c=>3, :d=>4}, 5=>{:a=>5, :b=>6, :c=>7, :d=>8}}
+    @ds.to_hash(:b).should == {2=>{:a=>1, :b=>2, :c=>3, :d=>4}, 6=>{:a=>5, :b=>6, :c=>7, :d=>8}}
+    @ds.to_hash([:a, :b]).should == {[1, 2]=>{:a=>1, :b=>2, :c=>3, :d=>4}, [5, 6]=>{:a=>5, :b=>6, :c=>7, :d=>8}}
+
+    @ds.to_hash(:a, :b).should == {1=>2, 5=>6}
+    @ds.to_hash([:a, :c], :b).should == {[1, 3]=>2, [5, 7]=>6}
+    @ds.to_hash(:a, [:b, :c]).should == {1=>[2, 3], 5=>[6, 7]}
+    @ds.to_hash([:a, :c], [:b, :d]).should == {[1, 3]=>[2, 4], [5, 7]=>[6, 8]}
+  end
+
+  specify "should have working #select_map" do
+    @ds.select_map(:a).should == [1, 5]
+    @ds.select_map(:b).should == [2, 6]
+    @ds.select_map([:a, :b]).should == [[1, 2], [5, 6]]
+
+    @ds.select_map(:a___e).should == [1, 5]
+    @ds.select_map(:b___e).should == [2, 6]
+    @ds.select_map([:a___e, :b___f]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a__a___e, :a__b___f]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a__a.as(:e), :a__b.as(:f)]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a.qualify(:a).as(:e), :b.qualify(:a).as(:f)]).should == [[1, 2], [5, 6]]
+    @ds.select_map([:a.identifier.qualify(:a).as(:e), :b.qualify(:a).as(:f)]).should == [[1, 2], [5, 6]]
+  end
+  
+  specify "should have working #select_order_map" do
+    @ds.select_order_map(:a).should == [1, 5]
+    @ds.select_order_map(:a__b.desc).should == [6, 2]
+    @ds.select_order_map(:a__b___e.desc).should == [6, 2]
+    @ds.select_order_map(:b.qualify(:a).as(:e)).should == [2, 6]
+    @ds.select_order_map([:a.desc, :b]).should == [[5, 6], [1, 2]]
+
+    @ds.select_order_map(:a___e).should == [1, 5]
+    @ds.select_order_map(:b___e).should == [2, 6]
+    @ds.select_order_map([:a___e.desc, :b___f]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a__a___e.desc, :a__b___f]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a__a.desc, :a__b.as(:f)]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a.qualify(:a).desc, :b.qualify(:a).as(:f)]).should == [[5, 6], [1, 2]]
+    @ds.select_order_map([:a.identifier.qualify(:a).desc, :b.qualify(:a).as(:f)]).should == [[5, 6], [1, 2]]
+  end
+
+  specify "should have working #select_hash" do
+    @ds.select_hash(:a, :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a__a___e, :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a__a.as(:e), :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a.qualify(:a).as(:e), :b).should == {1=>2, 5=>6}
+    @ds.select_hash(:a.identifier.qualify(:a).as(:e), :b).should == {1=>2, 5=>6}
+    @ds.select_hash([:a, :c], :b).should == {[1, 3]=>2, [5, 7]=>6}
+    @ds.select_hash(:a, [:b, :c]).should == {1=>[2, 3], 5=>[6, 7]}
+    @ds.select_hash([:a, :c], [:b, :d]).should == {[1, 3]=>[2, 4], [5, 7]=>[6, 8]}
+  end
+end
+
 describe "Sequel::Dataset DSL support" do
   before do
     @db = INTEGRATION_DB
@@ -685,7 +901,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.get{~b.sql_number}.to_i.should == -4
   end
   
-  cspecify "should work with the bitwise xor operator", :sqlite do
+  specify "should work with the bitwise xor operator" do
     @ds.insert(3, 5)
     @ds.get{a.sql_number ^ b}.to_i.should == 6
   end
@@ -778,7 +994,7 @@ describe "Sequel::Dataset DSL support" do
     @ds.filter({15=>20}.case(0, :a) > 0).all.should == []
   end
   
-  it "should work with multiple value arrays" do
+  specify "should work with multiple value arrays" do
     @ds.insert(20, 10)
     @ds.quote_identifiers = false
     @ds.filter([:a, :b]=>[[20, 10]].sql_array).all.should == [{:a=>20, :b=>10}]
@@ -847,12 +1063,16 @@ describe "SQL Extract Function" do
     @db.drop_table(:a)
   end
   
-  cspecify "should return the part of the datetime asked for", :sqlite, :mssql do
+  specify "should return the part of the datetime asked for" do
     t = Time.now
+    def @ds.supports_timestamp_timezones?() false end
     @ds.insert(t)
     @ds.get{a.extract(:year)}.should == t.year
     @ds.get{a.extract(:month)}.should == t.month
     @ds.get{a.extract(:day)}.should == t.day
+    @ds.get{a.extract(:hour)}.should == t.hour
+    @ds.get{a.extract(:minute)}.should == t.min
+    @ds.get{a.extract(:second)}.to_i.should == t.sec
   end
 end
 

data/spec/integration/plugin_test.rb

@@ -1,7 +1,9 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 # H2 and MSSQL don't support USING joins
-unless [:h2, :mssql].include?(INTEGRATION_DB.database_type)
+# DB2 does not seem to support USING joins in every version; it seems to be
+# valid expression in DB2 iSeries UDB though.
+unless [:h2, :mssql, :db2].include?(INTEGRATION_DB.database_type)
 describe "Class Table Inheritance Plugin" do
   before do
     @db = INTEGRATION_DB
@@ -110,13 +112,13 @@ describe "Class Table Inheritance Plugin" do
     @db[:executives][:id=>@i4].should == {:id=>@i4, :num_managers=>8}
   end
   
-  cspecify "should handle many_to_one relationships", :sqlite do
+  specify "should handle many_to_one relationships" do
     m = Staff.first.manager
     m.should == Manager[@i4]
     m.should be_a_kind_of(Executive)
   end
   
-  cspecify "should handle eagerly loading many_to_one relationships", :sqlite do
+  specify "should handle eagerly loading many_to_one relationships" do
     Staff.limit(1).eager(:manager).all.map{|x| x.manager}.should == [Manager[@i4]]
   end
   
@@ -196,6 +198,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 +213,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 +241,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 +256,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 +290,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 +305,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
 
@@ -525,7 +599,7 @@ describe "Composition plugin" do
       composition :date, :mapping=>[:year, :month, :day]
     end
     @e1 = Event.create(:year=>2010, :month=>2, :day=>15)
-    @e2 = Event.create({})
+    @e2 = Event.create(:year=>nil)
   end
   after do
     @db.drop_table(:events)
@@ -555,7 +629,8 @@ describe "Composition plugin" do
   end
 end
 
-if INTEGRATION_DB.dataset.supports_cte?
+# DB2's implemention of CTE is too limited to use this plugin
+if INTEGRATION_DB.dataset.supports_cte? and INTEGRATION_DB.database_type != :db2
   describe "RcteTree Plugin" do
     before do
       @db = INTEGRATION_DB
@@ -1306,3 +1381,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