sequel 3.21.0 → 3.41.0

data/spec/integration/plugin_test.rb

@@ -1,28 +1,33 @@
 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 !INTEGRATION_DB.dataset.supports_join_using? || Sequel.guarded?(:db2)
 describe "Class Table Inheritance Plugin" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.instance_variable_set(:@schemas, {})
-    @db.create_table!(:employees) do
+    @db.drop_table?(:staff, :executives, :managers, :employees)
+    @db.create_table(:employees) do
       primary_key :id
       String :name
       String :kind
     end
-    @db.create_table!(:managers) do
+    @db.create_table(:managers) do
       foreign_key :id, :employees, :primary_key=>true
       Integer :num_staff
     end
-    @db.create_table!(:executives) do
+    @db.create_table(:executives) do
       foreign_key :id, :managers, :primary_key=>true
       Integer :num_managers
     end
-    @db.create_table!(:staff) do
+    @db.create_table(:staff) do
       foreign_key :id, :employees, :primary_key=>true
       foreign_key :manager_id, :managers
     end
+  end
+  before do
+    [:staff, :executives, :managers, :employees].each{|t| @db[t].delete}
     class ::Employee < Sequel::Model(@db)
       plugin :class_table_inheritance, :key=>:kind, :table_map=>{:Staff=>:staff}
     end 
@@ -32,7 +37,7 @@ describe "Class Table Inheritance Plugin" do
     class ::Executive < Manager
     end 
     class ::Staff < Employee
-      many_to_one :manager
+      many_to_one :manager, :qualify=>false
     end 
     
     @i1 =@db[:employees].insert(:name=>'E', :kind=>'Employee')
@@ -43,13 +48,13 @@ describe "Class Table Inheritance Plugin" do
     @db[:managers].insert(:id=>@i4, :num_staff=>5)
     @db[:executives].insert(:id=>@i4, :num_managers=>6)
     @db[:staff].insert(:id=>@i2, :manager_id=>@i4)
-    
-    clear_sqls
   end
   after do
-    @db.drop_table :staff, :executives, :managers, :employees
     [:Executive, :Manager, :Staff, :Employee].each{|s| Object.send(:remove_const, s)}
   end
+  after(:all) do
+    @db.drop_table? :staff, :executives, :managers, :employees
+  end
 
   specify "should return rows as subclass instances" do
     Employee.order(:id).all.should == [
@@ -94,8 +99,7 @@ describe "Class Table Inheritance Plugin" do
     Employee.filter(:id=>@i2).all.first.manager.id.should == @i4
   end
 
-  # See http://www.sqlite.org/src/tktview/3338b3fa19ac4abee6c475126a2e6d9d61f26ab1
-  cspecify "should insert rows into all tables", :sqlite do
+  cspecify "should insert rows into all tables", [proc{|db| db.sqlite_version < 30709}, :sqlite] do
     e = Executive.create(:name=>'Ex2', :num_managers=>8, :num_staff=>9)
     i = e.id
     @db[:employees][:id=>i].should == {:id=>i, :name=>'Ex2', :kind=>'Executive'}
@@ -110,17 +114,17 @@ 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
   
-  cspecify "should handle eagerly graphing many_to_one relationships", :sqlite do
+  specify "should handle eagerly graphing many_to_one relationships" do
     ss = Staff.eager_graph(:manager).all
     ss.should == [Staff[@i2]]
     ss.map{|x| x.manager}.should == [Manager[@i4]]
@@ -134,7 +138,7 @@ describe "Class Table Inheritance Plugin" do
     Executive.limit(1).eager(:staff_members).first.staff_members.should == [Staff[@i2]]
   end
   
-  cspecify "should handle eagerly graphing one_to_many relationships", :sqlite do
+  cspecify "should handle eagerly graphing one_to_many relationships", [proc{|db| db.sqlite_version < 30709}, :sqlite] do
     es = Executive.limit(1).eager_graph(:staff_members).all
     es.should == [Executive[@i4]]
     es.map{|x| x.staff_members}.should == [[Staff[@i2]]]
@@ -143,21 +147,25 @@ end
 end
 
 describe "Many Through Many Plugin" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.instance_variable_set(:@schemas, {})
-    @db.create_table!(:albums) do
+    @db.drop_table?(:albums_artists, :albums, :artists)
+    @db.create_table(:albums) do
       primary_key :id
       String :name
     end
-    @db.create_table!(:artists) do
+    @db.create_table(:artists) do
       primary_key :id
       String :name
     end
-    @db.create_table!(:albums_artists) do
+    @db.create_table(:albums_artists) do
       foreign_key :album_id, :albums
       foreign_key :artist_id, :artists
     end
+  end
+  before do
+    [:albums_artists, :albums, :artists].each{|t| @db[t].delete}
     class ::Album < Sequel::Model(@db)
       many_to_many :artists
     end 
@@ -181,21 +189,31 @@ describe "Many Through Many Plugin" do
     @album4 = Album.create(:name=>'D')
     @album4.add_artist(@artist1)
     @album4.add_artist(@artist4)
-    
-    clear_sqls
   end
   after do
-    @db.drop_table :albums_artists, :albums, :artists
     [:Album, :Artist].each{|s| Object.send(:remove_const, s)}
   end
+  after(:all) do
+    @db.drop_table? :albums_artists, :albums, :artists
+  end
   
+  def self_join(c)
+    c.join(Sequel.as(c.table_name, :b), Array(c.primary_key).zip(Array(c.primary_key))).select_all(c.table_name)
+  end
+
   specify "should handle super simple case with 1 join table" do
     Artist.many_through_many :albums, [[:albums_artists, :artist_id, :album_id]]
-    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[@artist1.id].albums.map{|x| x.name}.sort.should == %w'A D'
+    Artist[@artist2.id].albums.map{|x| x.name}.sort.should == %w'A C'
+    Artist[@artist3.id].albums.map{|x| x.name}.sort.should == %w'B C'
+    Artist[@artist4.id].albums.map{|x| x.name}.sort.should == %w'B D'
     
+    Artist.plugin :prepared_statements_associations
+    Artist[@artist1.id].albums.map{|x| x.name}.sort.should == %w'A D'
+    Artist[@artist2.id].albums.map{|x| x.name}.sort.should == %w'A C'
+    Artist[@artist3.id].albums.map{|x| x.name}.sort.should == %w'B C'
+    Artist[@artist4.id].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,24 +223,102 @@ 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'
+
+    c = self_join(Artist)
+    c.filter(:albums=>@album1).all.map{|a| a.name}.sort.should == %w'1 2'
+    c.filter(:albums=>@album2).all.map{|a| a.name}.sort.should == %w'3 4'
+    c.filter(:albums=>@album3).all.map{|a| a.name}.sort.should == %w'2 3'
+    c.filter(:albums=>@album4).all.map{|a| a.name}.sort.should == %w'1 4'
+
+    c.exclude(:albums=>@album1).all.map{|a| a.name}.sort.should == %w'3 4'
+    c.exclude(:albums=>@album2).all.map{|a| a.name}.sort.should == %w'1 2'
+    c.exclude(:albums=>@album3).all.map{|a| a.name}.sort.should == %w'1 4'
+    c.exclude(:albums=>@album4).all.map{|a| a.name}.sort.should == %w'2 3'
+
+    c.filter(:albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    c.filter(:albums=>[@album2, @album4]).all.map{|a| a.name}.sort.should == %w'1 3 4'
+
+    c.exclude(:albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'4'
+    c.exclude(:albums=>[@album2, @album4]).all.map{|a| a.name}.sort.should == %w'2'
+
+    c.filter(:albums=>self_join(Album).filter(:albums__id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    c.exclude(:albums=>self_join(Album).filter(:albums__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
     Artist.many_through_many :related_artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]], :class=>Artist, :distinct=>true
-    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[@artist1.id].related_artists.map{|x| x.name}.sort.should == %w'1 2 4'
+    Artist[@artist2.id].related_artists.map{|x| x.name}.sort.should == %w'1 2 3'
+    Artist[@artist3.id].related_artists.map{|x| x.name}.sort.should == %w'2 3 4'
+    Artist[@artist4.id].related_artists.map{|x| x.name}.sort.should == %w'1 3 4'
+    
+    Artist.plugin :prepared_statements_associations
+    Artist[@artist1.id].related_artists.map{|x| x.name}.sort.should == %w'1 2 4'
+    Artist[@artist2.id].related_artists.map{|x| x.name}.sort.should == %w'1 2 3'
+    Artist[@artist3.id].related_artists.map{|x| x.name}.sort.should == %w'2 3 4'
+    Artist[@artist4.id].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'
-    Artist.filter(:id=>4).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 3 4'
+    Artist.filter(:id=>@artist1.id).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 4'
+    Artist.filter(:id=>@artist2.id).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 3'
+    Artist.filter(:id=>@artist3.id).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'2 3 4'
+    Artist.filter(:id=>@artist4.id).eager(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 3 4'
     
-    Artist.filter(:artists__id=>1).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 4'
-    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(:artists__id=>@artist1.id).eager_graph(:related_artists).all.map{|x| x.related_artists.map{|a| a.name}}.flatten.sort.should == %w'1 2 4'
+    Artist.filter(:artists__id=>@artist2.id).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=>@artist3.id).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=>@artist4.id).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'
+
+    c = self_join(Artist)
+    c.filter(:related_artists=>@artist1).all.map{|a| a.name}.sort.should == %w'1 2 4'
+    c.filter(:related_artists=>@artist2).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    c.filter(:related_artists=>@artist3).all.map{|a| a.name}.sort.should == %w'2 3 4'
+    c.filter(:related_artists=>@artist4).all.map{|a| a.name}.sort.should == %w'1 3 4'
+
+    c.exclude(:related_artists=>@artist1).all.map{|a| a.name}.sort.should == %w'3'
+    c.exclude(:related_artists=>@artist2).all.map{|a| a.name}.sort.should == %w'4'
+    c.exclude(:related_artists=>@artist3).all.map{|a| a.name}.sort.should == %w'1'
+    c.exclude(:related_artists=>@artist4).all.map{|a| a.name}.sort.should == %w'2'
+
+    c.filter(:related_artists=>[@artist1, @artist4]).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
+    c.exclude(:related_artists=>[@artist1, @artist4]).all.map{|a| a.name}.sort.should == %w''
+
+    c.filter(:related_artists=>c.filter(:artists__id=>@artist1.id)).all.map{|a| a.name}.sort.should == %w'1 2 4'
+    c.exclude(:related_artists=>c.filter(:artists__id=>@artist1.id)).all.map{|a| a.name}.sort.should == %w'3'
   end
 
   specify "should handle extreme case with 5 join tables" do
@@ -236,38 +332,84 @@ describe "Many Through Many Plugin" do
     @album4.add_artist(@artist3)
     @album4.add_artist(@artist4)
     
-    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[@artist1.id].related_albums.map{|x| x.name}.sort.should == %w'A B C'
+    Artist[@artist2.id].related_albums.map{|x| x.name}.sort.should == %w'A B C D'
+    Artist[@artist3.id].related_albums.map{|x| x.name}.sort.should == %w'A B D'
+    Artist[@artist4.id].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'
-    Artist.filter(:id=>4).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+    Artist.plugin :prepared_statements_associations
+    Artist[@artist1.id].related_albums.map{|x| x.name}.sort.should == %w'A B C'
+    Artist[@artist2.id].related_albums.map{|x| x.name}.sort.should == %w'A B C D'
+    Artist[@artist3.id].related_albums.map{|x| x.name}.sort.should == %w'A B D'
+    Artist[@artist4.id].related_albums.map{|x| x.name}.sort.should == %w'B D'
     
-    Artist.filter(:artists__id=>1).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C'
-    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(:id=>@artist1.id).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C'
+    Artist.filter(:id=>@artist2.id).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C D'
+    Artist.filter(:id=>@artist3.id).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B D'
+    Artist.filter(:id=>@artist4.id).eager(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'B D'
+    
+    Artist.filter(:artists__id=>@artist1.id).eager_graph(:related_albums).all.map{|x| x.related_albums.map{|a| a.name}}.flatten.sort.should == %w'A B C'
+    Artist.filter(:artists__id=>@artist2.id).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=>@artist3.id).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=>@artist4.id).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'
+
+    c = self_join(Artist)
+    c.filter(:related_albums=>@album1).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    c.filter(:related_albums=>@album2).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
+    c.filter(:related_albums=>@album3).all.map{|a| a.name}.sort.should == %w'1 2'
+    c.filter(:related_albums=>@album4).all.map{|a| a.name}.sort.should == %w'2 3 4'
+
+    c.exclude(:related_albums=>@album1).all.map{|a| a.name}.sort.should == %w'4'
+    c.exclude(:related_albums=>@album2).all.map{|a| a.name}.sort.should == %w''
+    c.exclude(:related_albums=>@album3).all.map{|a| a.name}.sort.should == %w'3 4'
+    c.exclude(:related_albums=>@album4).all.map{|a| a.name}.sort.should == %w'1'
+
+    c.filter(:related_albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    c.filter(:related_albums=>[@album3, @album4]).all.map{|a| a.name}.sort.should == %w'1 2 3 4'
+
+    c.exclude(:related_albums=>[@album1, @album3]).all.map{|a| a.name}.sort.should == %w'4'
+    c.exclude(:related_albums=>[@album2, @album4]).all.map{|a| a.name}.sort.should == %w''
+
+    c.filter(:related_albums=>self_join(Album).filter(:albums__id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'1 2 3'
+    c.exclude(:related_albums=>self_join(Album).filter(:albums__id=>[@album1.id, @album3.id])).all.map{|a| a.name}.sort.should == %w'4'
   end
 end
 
 describe "Lazy Attributes plugin" do 
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:items) do
       primary_key :id
       String :name
       Integer :num
     end
+    @db[:items].delete
     class ::Item < Sequel::Model(@db)
       plugin :lazy_attributes, :num
     end
     Item.create(:name=>'J', :num=>1)
   end
-  after do
-    @db.drop_table(:items)
+  after(:all) do
+    @db.drop_table?(:items)
     Object.send(:remove_const, :Item)
   end
   
@@ -299,7 +441,7 @@ describe "Lazy Attributes plugin" do
 end
 
 describe "Tactical Eager Loading Plugin" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.instance_variable_set(:@schemas, {})
     @db.create_table!(:artists) do
@@ -311,6 +453,10 @@ describe "Tactical Eager Loading Plugin" do
       String :name
       foreign_key :artist_id, :artists
     end
+  end
+  before do
+    @db[:albums].delete
+    @db[:artists].delete
     class ::Album < Sequel::Model(@db)
       plugin :tactical_eager_loading
       many_to_one :artist
@@ -328,13 +474,13 @@ describe "Tactical Eager Loading Plugin" do
     @album2 = Album.create(:name=>'B', :artist=>@artist1)
     @album3 = Album.create(:name=>'C', :artist=>@artist2)
     @album4 = Album.create(:name=>'D', :artist=>@artist3)
-    
-    clear_sqls
   end
   after do
-    @db.drop_table :albums, :artists
     [:Album, :Artist].each{|s| Object.send(:remove_const, s)}
   end
+  after(:all) do
+    @db.drop_table? :albums, :artists
+  end
 
   specify "should eagerly load associations for all items when accessing any item" do
     a = Artist.order(:name).all
@@ -363,7 +509,7 @@ describe "Identity Map plugin" do
     Item.create(:name=>'J', :num=>3)
   end
   after do
-    @db.drop_table(:items)
+    @db.drop_table?(:items)
     Object.send(:remove_const, :Item)
   end
 
@@ -382,56 +528,91 @@ describe "Identity Map plugin" do
 end
 
 describe "Touch plugin" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
-    @db.instance_variable_set(:@schemas, {})
-    @db.create_table!(:artists) do
+    @db.drop_table? :albums_artists, :albums, :artists
+    @db.create_table(:artists) do
       primary_key :id
       String :name
       DateTime :updated_at
     end
-    @db.create_table!(:albums) do
+    @db.create_table(:albums) do
       primary_key :id
       String :name
       foreign_key :artist_id, :artists
       DateTime :updated_at
     end
+    @db.create_join_table({:album_id=>:albums, :artist_id=>:artists}, :no_index=>true)
+  end
+  before do
+    @db[:albums].delete
+    @db[:artists].delete
     class ::Album < Sequel::Model(@db)
-      many_to_one :artist
-      plugin :touch, :associations=>:artist
     end
     class ::Artist < Sequel::Model(@db)
     end 
     
     @artist = Artist.create(:name=>'1')
-    @album = Album.create(:name=>'A', :artist=>@artist)
+    @album = Album.create(:name=>'A', :artist_id=>@artist.id)
   end
   after do
-    @db.drop_table :albums, :artists
     [:Album, :Artist].each{|s| Object.send(:remove_const, s)}
   end
+  after(:all) do
+    @db.drop_table? :albums_artists, :albums, :artists
+  end
 
   specify "should update the timestamp column when touching the record" do
+    Album.plugin :touch
     @album.updated_at.should == nil
     @album.touch
     @album.updated_at.to_i.should be_within(2).of(Time.now.to_i)
   end
   
-  cspecify "should update the timestamp column for associated records when the record is updated or destroyed", [:do, :sqlite], [:jdbc, :sqlite] do
+  cspecify "should update the timestamp column for many_to_one associated records when the record is updated or destroyed", [:do, :sqlite], [:jdbc, :sqlite], [:swift] do
+    Album.many_to_one :artist
+    Album.plugin :touch, :associations=>:artist
     @artist.updated_at.should == nil
     @album.update(:name=>'B')
     ua = @artist.reload.updated_at
     if ua.is_a?(Time)
-      ua.to_i.should be_within(2).of(Time.now.to_i)
+      ua.to_i.should be_within(60).of(Time.now.to_i)
     else
-      (DateTime.now - ua).should be_within(2.0/86400).of(0)
+      (DateTime.now - ua).should be_within(60.0/86400).of(0)
     end
     @artist.update(:updated_at=>nil)
     @album.destroy
     if ua.is_a?(Time)
-      ua.to_i.should be_within(2).of(Time.now.to_i)
+      ua.to_i.should be_within(60).of(Time.now.to_i)
+    else
+      (DateTime.now - ua).should be_within(60.0/86400).of(0)
+    end
+  end
+
+  cspecify "should update the timestamp column for one_to_many associated records when the record is updated", [:do, :sqlite], [:jdbc, :sqlite], [:swift] do
+    Artist.one_to_many :albums
+    Artist.plugin :touch, :associations=>:albums
+    @album.updated_at.should == nil
+    @artist.update(:name=>'B')
+    ua = @album.reload.updated_at
+    if ua.is_a?(Time)
+      ua.to_i.should be_within(60).of(Time.now.to_i)
+    else
+      (DateTime.now - ua).should be_within(60.0/86400).of(0)
+    end
+  end
+
+  cspecify "should update the timestamp column for many_to_many associated records when the record is updated", [:do, :sqlite], [:jdbc, :sqlite], [:swift] do
+    Artist.many_to_many :albums
+    Artist.plugin :touch, :associations=>:albums
+    @artist.add_album(@album)
+    @album.updated_at.should == nil
+    @artist.update(:name=>'B')
+    ua = @album.reload.updated_at
+    if ua.is_a?(Time)
+      ua.to_i.should be_within(60).of(Time.now.to_i)
     else
-      (DateTime.now - ua).should be_within(2.0/86400).of(0)
+      (DateTime.now - ua).should be_within(60.0/86400).of(0)
     end
   end
 end
@@ -448,7 +629,7 @@ describe "Serialization plugin" do
     end
   end
   after do
-    @db.drop_table(:items)
+    @db.drop_table?(:items)
     Object.send(:remove_const, :Item)
   end
 
@@ -464,7 +645,7 @@ describe "Serialization plugin" do
 end
 
 describe "OptimisticLocking plugin" do 
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:people) do
       primary_key :id
@@ -473,30 +654,33 @@ describe "OptimisticLocking plugin" do
     end
     class ::Person < Sequel::Model(@db)
       plugin :optimistic_locking
-      create(:name=>'John')
     end
   end
-  after do
-    @db.drop_table(:people)
+  before do
+    @db[:people].delete
+    @p = Person.create(:name=>'John')
+  end
+  after(:all) do
+    @db.drop_table?(:people)
     Object.send(:remove_const, :Person)
   end
 
   specify "should raise an error when updating a stale record" do
-    p1 = Person[1]
-    p2 = Person[1]
+    p1 = Person[@p.id]
+    p2 = Person[@p.id]
     p1.update(:name=>'Jim')
     proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
   end
 
   specify "should raise an error when destroying a stale record" do
-    p1 = Person[1]
-    p2 = Person[1]
+    p1 = Person[@p.id]
+    p2 = Person[@p.id]
     p1.update(:name=>'Jim')
     proc{p2.destroy}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
   end
 
   specify "should not raise an error when updating the same record twice" do
-    p1 = Person[1]
+    p1 = Person[@p.id]
     p1.update(:name=>'Jim')
     proc{p1.update(:name=>'Bob')}.should_not raise_error
   end
@@ -525,10 +709,10 @@ 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)
+    @db.drop_table?(:events)
     Object.send(:remove_const, :Event)
   end
 
@@ -555,9 +739,10 @@ 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 !Sequel.guarded?(:db2)
   describe "RcteTree Plugin" do
-    before do
+    before(:all) do
       @db = INTEGRATION_DB
       @db.create_table!(:nodes) do
         primary_key :id
@@ -568,22 +753,26 @@ if INTEGRATION_DB.dataset.supports_cte?
         plugin :rcte_tree, :order=>:name
       end
       
-      @a = Node.create(:name=>'a')
-      @b = Node.create(:name=>'b')
-      @aa = Node.create(:name=>'aa', :parent=>@a)
-      @ab = Node.create(:name=>'ab', :parent=>@a)
-      @ba = Node.create(:name=>'ba', :parent=>@b)
-      @bb = Node.create(:name=>'bb', :parent=>@b)
-      @aaa = Node.create(:name=>'aaa', :parent=>@aa)
-      @aab = Node.create(:name=>'aab', :parent=>@aa)
-      @aba = Node.create(:name=>'aba', :parent=>@ab)
-      @abb = Node.create(:name=>'abb', :parent=>@ab)
-      @aaaa = Node.create(:name=>'aaaa', :parent=>@aaa)
-      @aaab = Node.create(:name=>'aaab', :parent=>@aaa)
-      @aaaaa = Node.create(:name=>'aaaaa', :parent=>@aaaa)
-    end
-    after do
-      @db.drop_table :nodes
+      @nodes = []
+      @nodes << @a = Node.create(:name=>'a')
+      @nodes << @b = Node.create(:name=>'b')
+      @nodes << @aa = Node.create(:name=>'aa', :parent=>@a)
+      @nodes << @ab = Node.create(:name=>'ab', :parent=>@a)
+      @nodes << @ba = Node.create(:name=>'ba', :parent=>@b)
+      @nodes << @bb = Node.create(:name=>'bb', :parent=>@b)
+      @nodes << @aaa = Node.create(:name=>'aaa', :parent=>@aa)
+      @nodes << @aab = Node.create(:name=>'aab', :parent=>@aa)
+      @nodes << @aba = Node.create(:name=>'aba', :parent=>@ab)
+      @nodes << @abb = Node.create(:name=>'abb', :parent=>@ab)
+      @nodes << @aaaa = Node.create(:name=>'aaaa', :parent=>@aaa)
+      @nodes << @aaab = Node.create(:name=>'aaab', :parent=>@aaa)
+      @nodes << @aaaaa = Node.create(:name=>'aaaaa', :parent=>@aaaa)
+    end
+    before do
+      @nodes.each{|n| n.associations.clear}
+    end
+    after(:all) do
+      @db.drop_table? :nodes
       Object.send(:remove_const, :Node)
     end
     
@@ -659,13 +848,15 @@ if INTEGRATION_DB.dataset.supports_cte?
     end
 
     specify "should work correctly if not all columns are selected" do
-      Node.plugin :lazy_attributes, :name
-      @aaaa.descendants.should == [Node.load(:parent_id=>11, :id=>13)]
-      @aa.ancestors.should == [Node.load(:parent_id=>nil, :id=>1)]
-      nodes = Node.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:ancestors, :descendants).all
-      nodes.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>3, :id=>7}, {:parent_id=>nil, :id=>2}].map{|x| Node.load(x)}
-      nodes[2].descendants.should == [{:parent_id=>2, :id=>5}, {:parent_id=>2, :id=>6}].map{|x| Node.load(x)}
-      nodes[1].ancestors.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>1, :id=>3}].map{|x| Node.load(x)}
+      c = Class.new(Sequel::Model(@db[:nodes]))
+      c.plugin :rcte_tree, :order=>:name
+      c.plugin :lazy_attributes, :name
+      c[:name=>'aaaa'].descendants.should == [c.load(:parent_id=>11, :id=>13)]
+      c[:name=>'aa'].ancestors.should == [c.load(:parent_id=>nil, :id=>1)]
+      nodes = c.filter(:id=>[@a.id, @b.id, @aaa.id]).order(:name).eager(:ancestors, :descendants).all
+      nodes.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>3, :id=>7}, {:parent_id=>nil, :id=>2}].map{|x| c.load(x)}
+      nodes[2].descendants.should == [{:parent_id=>2, :id=>5}, {:parent_id=>2, :id=>6}].map{|x| c.load(x)}
+      nodes[1].ancestors.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>1, :id=>3}].map{|x| c.load(x)}
     end
     
     specify "should eagerly load descendants to a given level" do
@@ -751,7 +942,7 @@ if INTEGRATION_DB.dataset.supports_cte?
       nodes[0].associations.fetch(:parent, 1).should == nil
       nodes[1].associations[:parent].should == @aa
       nodes[1].associations[:parent].associations[:parent].should == @a
-      nodes[1].associations[:parent].associations[:parent].associations.fetch(:parent, 1) == nil
+      nodes[1].associations[:parent].associations[:parent].associations.fetch(:parent, 1).should == nil
       nodes[2].associations[:parent].should == @aaaa
       nodes[2].associations[:parent].associations[:parent].should == @aaa
       nodes[2].associations[:parent].associations[:parent].associations[:parent].should == @aa
@@ -783,7 +974,7 @@ if INTEGRATION_DB.dataset.supports_cte?
 end
 
 describe "Instance Filters plugin" do 
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:items) do
       primary_key :id
@@ -794,12 +985,15 @@ describe "Instance Filters plugin" do
     class ::Item < Sequel::Model(@db)
       plugin :instance_filters
     end
+  end
+  before do
+    @db[:items].delete
     @i = Item.create(:name=>'J', :number=>1, :cost=>2)
     @i.instance_filter(:number=>1)
     @i.set(:name=>'K')
   end
-  after do
-    @db.drop_table(:items)
+  after(:all) do
+    @db.drop_table?(:items)
     Object.send(:remove_const, :Item)
   end
   
@@ -843,21 +1037,24 @@ describe "Instance Filters plugin" do
 end
 
 describe "UpdatePrimaryKey plugin" do 
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
     @db.create_table!(:t) do
       Integer :a, :primary_key=>true
       Integer :b
     end
     @ds = @db[:t]
-    @ds.insert(:a=>1, :b=>3)
     @c = Class.new(Sequel::Model(@ds))
     @c.set_primary_key(:a)
     @c.unrestrict_primary_key
     @c.plugin :update_primary_key
   end
-  after do
-    @db.drop_table(:t)
+  before do
+    @ds.delete
+    @ds.insert(:a=>1, :b=>3)
+  end
+  after(:all) do
+    @db.drop_table?(:t)
   end
 
   specify "should handle regular updates" do
@@ -898,25 +1095,66 @@ describe "UpdatePrimaryKey plugin" do
 end
 
 describe "AssociationPks plugin" do 
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
-    @db.create_table!(:artists) do
+    @db.drop_table?(:albums_tags, :albums_vocalists, :vocalists_instruments, :vocalists_hits, :hits, :instruments, :vocalists, :tags, :albums, :artists)
+    @db.create_table(:artists) do
       primary_key :id
       String :name
     end
-    @db.create_table!(:albums) do
+    @db.create_table(:albums) do
       primary_key :id
       String :name
       foreign_key :artist_id, :artists
     end
-    @db.create_table!(:tags) do
+    @db.create_table(:tags) do
       primary_key :id
       String :name
     end
-    @db.create_table!(:albums_tags) do
+    @db.create_table(:albums_tags) do
       foreign_key :album_id, :albums
       foreign_key :tag_id, :tags
     end
+    @db.create_table(:vocalists) do
+      String :first
+      String :last
+      primary_key [:first, :last]
+      foreign_key :album_id, :albums
+    end
+    @db.create_table(:albums_vocalists) do
+      foreign_key :album_id, :albums
+      String :first
+      String :last
+      foreign_key [:first, :last], :vocalists
+    end
+    @db.create_table(:instruments) do
+      primary_key :id
+      String :first
+      String :last
+      foreign_key [:first, :last], :vocalists
+    end
+    @db.create_table(:vocalists_instruments) do
+      String :first
+      String :last
+      foreign_key [:first, :last], :vocalists
+      foreign_key :instrument_id, :instruments
+    end
+    @db.create_table(:hits) do
+      Integer :year
+      Integer :week
+      primary_key [:year, :week]
+      String :first
+      String :last
+      foreign_key [:first, :last], :vocalists
+    end
+    @db.create_table(:vocalists_hits) do
+      String :first
+      String :last
+      foreign_key [:first, :last], :vocalists
+      Integer :year
+      Integer :week
+      foreign_key [:year, :week], :hits
+    end
     class ::Artist < Sequel::Model
       plugin :association_pks
       one_to_many :albums, :order=>:id
@@ -927,7 +1165,19 @@ describe "AssociationPks plugin" do
     end 
     class ::Tag < Sequel::Model
     end 
-    
+    class ::Vocalist < Sequel::Model
+      set_primary_key [:first, :last]
+      plugin :association_pks
+    end
+    class ::Instrument < Sequel::Model
+      plugin :association_pks
+    end
+    class ::Hit < Sequel::Model
+      set_primary_key [:year, :week]
+    end
+  end
+  before do
+    [:albums_tags, :albums_vocalists, :vocalists_instruments, :vocalists_hits, :hits, :instruments, :vocalists, :tags, :albums, :artists].each{|t| @db[t].delete}
     @ar1 =@db[:artists].insert(:name=>'YJM')
     @ar2 =@db[:artists].insert(:name=>'AS')
     @al1 =@db[:albums].insert(:name=>'RF', :artist_id=>@ar1)
@@ -939,10 +1189,34 @@ describe "AssociationPks plugin" do
     {@al1=>[@t1, @t2, @t3], @al2=>[@t2]}.each do |aid, tids|
       tids.each{|tid| @db[:albums_tags].insert([aid, tid])}
     end
+    @v1 = ['F1', 'L1']
+    @v2 = ['F2', 'L2']
+    @v3 = ['F3', 'L3']
+    @db[:vocalists].insert(@v1 + [@al1])
+    @db[:vocalists].insert(@v2 + [@al1])
+    @db[:vocalists].insert(@v3 + [@al1])
+    @i1 = @db[:instruments].insert([:first, :last], @v1)
+    @i2 = @db[:instruments].insert([:first, :last], @v1)
+    @i3 = @db[:instruments].insert([:first, :last], @v1)
+    @h1 = [1997, 1]
+    @h2 = [1997, 2]
+    @h3 = [1997, 3]
+    @db[:hits].insert(@h1 + @v1)
+    @db[:hits].insert(@h2 + @v1)
+    @db[:hits].insert(@h3 + @v1)
+    {@al1=>[@v1, @v2, @v3], @al2=>[@v2]}.each do |aid, vids|
+      vids.each{|vid| @db[:albums_vocalists].insert([aid] + vid)}
+    end
+    {@v1=>[@i1, @i2, @i3], @v2=>[@i2]}.each do |vid, iids|
+      iids.each{|iid| @db[:vocalists_instruments].insert(vid + [iid])}
+    end
+    {@v1=>[@h1, @h2, @h3], @v2=>[@h2]}.each do |vid, hids|
+      hids.each{|hid| @db[:vocalists_hits].insert(vid + hid)}
+    end
   end
-  after do
-    @db.drop_table :albums_tags, :tags, :albums, :artists
-    [:Artist, :Album, :Tag].each{|s| Object.send(:remove_const, s)}
+  after(:all) do
+    @db.drop_table? :albums_tags, :albums_vocalists, :vocalists_instruments, :vocalists_hits, :hits, :instruments, :vocalists, :tags, :albums, :artists
+    [:Artist, :Album, :Tag, :Vocalist, :Instrument, :Hit].each{|s| Object.send(:remove_const, s)}
   end
 
   specify "should return correct associated pks for one_to_many associations" do
@@ -953,6 +1227,36 @@ describe "AssociationPks plugin" do
     Album.order(:id).all.map{|a| a.tag_pks.sort}.should == [[@t1, @t2, @t3], [@t2], []]
   end
 
+  specify "should return correct associated right-side cpks for one_to_many associations" do
+    Album.one_to_many :vocalists, :order=>:first
+    Album.order(:id).all.map{|a| a.vocalist_pks.sort}.should == [[@v1, @v2, @v3], [], []]
+  end
+
+  specify "should return correct associated right-side cpks for many_to_many associations" do
+    Album.many_to_many :vocalists, :join_table=>:albums_vocalists, :right_key=>[:first, :last], :order=>:first
+    Album.order(:id).all.map{|a| a.vocalist_pks.sort}.should == [[@v1, @v2, @v3], [@v2], []]
+  end
+
+  specify "should return correct associated pks for left-side cpks for one_to_many associations" do
+    Vocalist.one_to_many :instruments, :key=>[:first, :last], :order=>:id
+    Vocalist.order(:first, :last).all.map{|a| a.instrument_pks.sort}.should == [[@i1, @i2, @i3], [], []]
+  end
+
+  specify "should return correct associated pks for left-side cpks for many_to_many associations" do
+    Vocalist.many_to_many :instruments, :join_table=>:vocalists_instruments, :left_key=>[:first, :last], :order=>:id
+    Vocalist.order(:first, :last).all.map{|a| a.instrument_pks.sort}.should == [[@i1, @i2, @i3], [@i2], []]
+  end
+
+  specify "should return correct associated right-side cpks for left-side cpks for one_to_many associations" do
+    Vocalist.one_to_many :hits, :key=>[:first, :last], :order=>:week
+    Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.should == [[@h1, @h2, @h3], [], []]
+  end
+
+  specify "should return correct associated right-side cpks for left-side cpks for many_to_many associations" do
+    Vocalist.many_to_many :hits, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :order=>:week
+    Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.should == [[@h1, @h2, @h3], [@h2], []]
+  end
+
   specify "should set associated pks correctly for a one_to_many association" do
     Artist.use_transactions = true
     Album.order(:id).select_map(:artist_id).should == [@ar1, @ar1, @ar1]
@@ -990,13 +1294,135 @@ describe "AssociationPks plugin" do
     Album[@al3].tag_pks = []
     @db[:albums_tags].filter(:album_id=>@al1).select_order_map(:tag_id).should == []
   end
-end
 
+  specify "should set associated right-side cpks correctly for a one_to_many association" do
+    Album.use_transactions = true
+    Album.one_to_many :vocalists, :order=>:first
+    Album.order(:id).all.map{|a| a.vocalist_pks.sort}.should == [[@v1, @v2, @v3], [], []]
+
+    Album[@al2].vocalist_pks = [@v1, @v3]
+    Album[@al1].vocalist_pks.should == [@v2]
+    Vocalist.order(:first, :last).select_map(:album_id).should == [@al2, @al1, @al2]
+
+    Album[@al1].vocalist_pks = [@v1]
+    Album[@al2].vocalist_pks.should == [@v3]
+    Vocalist.order(:first, :last).select_map(:album_id).should == [@al1, nil, @al2]
+
+    Album[@al1].vocalist_pks = [@v1, @v2]
+    Album[@al2].vocalist_pks.should == [@v3]
+    Vocalist.order(:first, :last).select_map(:album_id).should == [@al1, @al1, @al2]
+  end
+
+  specify "should set associated right-side cpks correctly for a many_to_many association" do
+    Album.use_transactions = true
+    Album.many_to_many :vocalists, :join_table=>:albums_vocalists, :right_key=>[:first, :last], :order=>:first
+
+    @db[:albums_vocalists].filter(:album_id=>@al1).select_order_map([:first, :last]).should == [@v1, @v2, @v3]
+    Album[@al1].vocalist_pks = [@v1, @v3]
+    @db[:albums_vocalists].filter(:album_id=>@al1).select_order_map([:first, :last]).should == [@v1, @v3]
+    Album[@al1].vocalist_pks = []
+    @db[:albums_vocalists].filter(:album_id=>@al1).select_order_map([:first, :last]).should == []
+
+    @db[:albums_vocalists].filter(:album_id=>@al2).select_order_map([:first, :last]).should == [@v2]
+    Album[@al2].vocalist_pks = [@v1, @v2]
+    @db[:albums_vocalists].filter(:album_id=>@al2).select_order_map([:first, :last]).should == [@v1, @v2]
+    Album[@al2].vocalist_pks = []
+    @db[:albums_vocalists].filter(:album_id=>@al1).select_order_map([:first, :last]).should == []
+
+    @db[:albums_vocalists].filter(:album_id=>@al3).select_order_map([:first, :last]).should == []
+    Album[@al3].vocalist_pks = [@v1, @v3]
+    @db[:albums_vocalists].filter(:album_id=>@al3).select_order_map([:first, :last]).should == [@v1, @v3]
+    Album[@al3].vocalist_pks = []
+    @db[:albums_vocalists].filter(:album_id=>@al1).select_order_map([:first, :last]).should == []
+  end
+
+  specify "should set associated pks correctly with left-side cpks for a one_to_many association" do
+    Vocalist.use_transactions = true
+    Vocalist.one_to_many :instruments, :key=>[:first, :last], :order=>:id
+    Vocalist.order(:first, :last).all.map{|a| a.instrument_pks.sort}.should == [[@i1, @i2, @i3], [], []]
+
+    Vocalist[@v2].instrument_pks = [@i1, @i3]
+    Vocalist[@v1].instrument_pks.should == [@i2]
+    Instrument.order(:id).select_map([:first, :last]).should == [@v2, @v1, @v2]
+
+    Vocalist[@v1].instrument_pks = [@i1]
+    Vocalist[@v2].instrument_pks.should == [@i3]
+    Instrument.order(:id).select_map([:first, :last]).should == [@v1, [nil, nil], @v2]
+
+    Vocalist[@v1].instrument_pks = [@i1, @i2]
+    Vocalist[@v2].instrument_pks.should == [@i3]
+    Instrument.order(:id).select_map([:first, :last]).should == [@v1, @v1, @v2]
+  end
+
+  specify "should set associated pks correctly with left-side cpks for a many_to_many association" do
+    Vocalist.use_transactions = true
+    Vocalist.many_to_many :instruments, :join_table=>:vocalists_instruments, :left_key=>[:first, :last], :order=>:id
+
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v1]).select_order_map(:instrument_id).should == [@i1, @i2, @i3]
+    Vocalist[@v1].instrument_pks = [@i1, @i3]
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v1]).select_order_map(:instrument_id).should == [@i1, @i3]
+    Vocalist[@v1].instrument_pks = []
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v1]).select_order_map(:instrument_id).should == []
+
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v2]).select_order_map(:instrument_id).should == [@i2]
+    Vocalist[@v2].instrument_pks = [@i1, @i2]
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v2]).select_order_map(:instrument_id).should == [@i1, @i2]
+    Vocalist[@v2].instrument_pks = []
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v1]).select_order_map(:instrument_id).should == []
+
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v3]).select_order_map(:instrument_id).should == []
+    Vocalist[@v3].instrument_pks = [@i1, @i3]
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v3]).select_order_map(:instrument_id).should == [@i1, @i3]
+    Vocalist[@v3].instrument_pks = []
+    @db[:vocalists_instruments].filter([:first, :last]=>[@v1]).select_order_map(:instrument_id).should == []
+  end
+
+  specify "should set associated right-side cpks correctly with left-side cpks for a one_to_many association" do
+    Vocalist.use_transactions = true
+    Vocalist.one_to_many :hits, :key=>[:first, :last], :order=>:week
+    Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.should == [[@h1, @h2, @h3], [], []]
+
+    Vocalist[@v2].hit_pks = [@h1, @h3]
+    Vocalist[@v1].hit_pks.should == [@h2]
+    Hit.order(:year, :week).select_map([:first, :last]).should == [@v2, @v1, @v2]
+
+    Vocalist[@v1].hit_pks = [@h1]
+    Vocalist[@v2].hit_pks.should == [@h3]
+    Hit.order(:year, :week).select_map([:first, :last]).should == [@v1, [nil, nil], @v2]
+
+    Vocalist[@v1].hit_pks = [@h1, @h2]
+    Vocalist[@v2].hit_pks.should == [@h3]
+    Hit.order(:year, :week).select_map([:first, :last]).should == [@v1, @v1, @v2]
+  end
+
+  specify "should set associated right-side cpks correctly with left-side cpks for a many_to_many association" do
+    Vocalist.use_transactions = true
+    Vocalist.many_to_many :hits, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :order=>:week
+
+    @db[:vocalists_hits].filter([:first, :last]=>[@v1]).select_order_map([:year, :week]).should == [@h1, @h2, @h3]
+    Vocalist[@v1].hit_pks = [@h1, @h3]
+    @db[:vocalists_hits].filter([:first, :last]=>[@v1]).select_order_map([:year, :week]).should == [@h1, @h3]
+    Vocalist[@v1].hit_pks = []
+    @db[:vocalists_hits].filter([:first, :last]=>[@v1]).select_order_map([:year, :week]).should == []
+
+    @db[:vocalists_hits].filter([:first, :last]=>[@v2]).select_order_map([:year, :week]).should == [@h2]
+    Vocalist[@v2].hit_pks = [@h1, @h2]
+    @db[:vocalists_hits].filter([:first, :last]=>[@v2]).select_order_map([:year, :week]).should == [@h1, @h2]
+    Vocalist[@v2].hit_pks = []
+    @db[:vocalists_hits].filter([:first, :last]=>[@v1]).select_order_map([:year, :week]).should == []
+
+    @db[:vocalists_hits].filter([:first, :last]=>[@v3]).select_order_map([:year, :week]).should == []
+    Vocalist[@v3].hit_pks = [@h1, @h3]
+    @db[:vocalists_hits].filter([:first, :last]=>[@v3]).select_order_map([:year, :week]).should == [@h1, @h3]
+    Vocalist[@v3].hit_pks = []
+    @db[:vocalists_hits].filter([:first, :last]=>[@v1]).select_order_map([:year, :week]).should == []
+  end
+end
 
 describe "List plugin without a scope" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
-    @db.create_table :sites do
+    @db.create_table!(:sites) do
       primary_key :id
       String :name
       Integer :position
@@ -1004,14 +1430,15 @@ describe "List plugin without a scope" do
 
     @c = Class.new(Sequel::Model(@db[:sites]))
     @c.plugin :list
+  end
+  before do
     @c.delete
-    @c.create :name => "hig", :position => 3
-    @c.create :name => "def", :position => 2
-    @c.create :name => "abc", :position => 1
+    @c.create :name => "abc"
+    @c.create :name => "def"
+    @c.create :name => "hig"
   end
-
-  after do
-    @db.drop_table(:sites)
+  after(:all) do
+    @db.drop_table?(:sites)
   end
 
   it "should return rows in order of position" do
@@ -1067,9 +1494,9 @@ describe "List plugin without a scope" do
 end
 
 describe "List plugin with a scope" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
-    @db.create_table :pages do
+    @db.create_table!(:pages) do
       primary_key :id
       String :name
       Integer :pos
@@ -1078,19 +1505,21 @@ describe "List plugin with a scope" do
 
     @c = Class.new(Sequel::Model(@db[:pages]))
     @c.plugin :list, :field => :pos, :scope => :parent_id
-    p1 = @c.create :name => "Hm", :pos => 1, :parent_id => 0
-    p2 = @c.create :name => "Ps", :pos => 1, :parent_id => p1.id
-    @c.create :name => "P1", :pos => 1, :parent_id => p2.id
-    @c.create :name => "P2", :pos => 2, :parent_id => p2.id
-    @c.create :name => "P3", :pos => 3, :parent_id => p2.id
-    @c.create :name => "Au", :pos => 2, :parent_id => p1.id
   end
-
-  after do
-    @db.drop_table(:pages)
+  before do
+    @c.delete
+    p1 = @c.create :name => "Hm", :parent_id => 0
+    p2 = @c.create :name => "Ps", :parent_id => p1.id
+    @c.create :name => "P1", :parent_id => p2.id
+    @c.create :name => "P2", :parent_id => p2.id
+    @c.create :name => "P3", :parent_id => p2.id
+    @c.create :name => "Au", :parent_id => p1.id
+  end
+  after(:all) do
+    @db.drop_table?(:pages)
   end
 
-  it "should return rows in order of position" do
+  specify "should return rows in order of position" do
     @c.map(:name).should == %w[ Hm Ps Au P1 P2 P3 ]
   end
 
@@ -1111,7 +1540,7 @@ describe "List plugin with a scope" do
     @c[:name => "P3"].next.should == nil
   end
 
-  it "should define move_to" do
+  specify "should define move_to" do
     @c[:name => "P2"].move_to(1)
     @c.map(:name).should == %w[ Hm Ps Au P2 P1 P3 ]
 
@@ -1122,7 +1551,7 @@ describe "List plugin with a scope" do
     proc { @c[:name => "P2"].move_to(10) }.should raise_error(Sequel::Error)
   end
 
-  it "should define move_to_top and move_to_bottom" do
+  specify "should define move_to_top and move_to_bottom" do
     @c[:name => "Au"].move_to_top
     @c.map(:name).should == %w[ Hm Au Ps P1 P2 P3 ]
 
@@ -1130,7 +1559,7 @@ describe "List plugin with a scope" do
     @c.map(:name).should == %w[ Hm Ps Au P1 P2 P3 ]
   end
 
-  it "should define move_up and move_down" do
+  specify "should define move_up and move_down" do
     @c[:name => "P2"].move_up
     @c.map(:name).should == %w[ Hm Ps Au P2 P1 P3 ]
 
@@ -1143,12 +1572,12 @@ describe "List plugin with a scope" do
 end
 
 describe "Sequel::Plugins::Tree" do
-  before do
+  before(:all) do
     @db = INTEGRATION_DB
   end
 
   describe "with natural database order" do
-    before do
+    before(:all) do
       @db.create_table!(:nodes) do
         Integer :id, :primary_key=>true
         String :name
@@ -1174,8 +1603,8 @@ describe "Sequel::Plugins::Tree" do
         plugin :tree
       end
     end
-    after do
-      @db.drop_table(:nodes)
+    after(:all) do
+      @db.drop_table?(:nodes)
       Object.send(:remove_const, :Node)
     end
 
@@ -1249,12 +1678,12 @@ describe "Sequel::Plugins::Tree" do
     end
 
     describe "Nodes in specified order" do
-      before do
+      before(:all) do
         class ::OrderedNode < Sequel::Model(:nodes)
           plugin :tree, :order => :position
         end
       end
-      after do
+      after(:all) do
         Object.send(:remove_const, :OrderedNode)
       end
 
@@ -1272,7 +1701,7 @@ describe "Sequel::Plugins::Tree" do
   end
 
   describe "Lorems in specified order" do
-    before do
+    before(:all) do
       @db.create_table!(:lorems) do
         Integer :id, :primary_key=>true
         String :name
@@ -1290,8 +1719,8 @@ describe "Sequel::Plugins::Tree" do
         plugin :tree, :key => :ipsum_id, :order => :neque
       end
     end
-    after do
-      @db.drop_table(:lorems)
+    after(:all) do
+      @db.drop_table?(:lorems)
       Object.send(:remove_const, :Lorem)
     end
 
@@ -1306,3 +1735,285 @@ describe "Sequel::Plugins::Tree" do
     end
   end
 end
+
+describe "Sequel::Plugins::PreparedStatements" do
+  before(:all) 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]))
+    @c.plugin :prepared_statements_with_pk
+  end
+  before do
+    @c.delete
+    @foo = @c.create(:name=>'foo', :i=>10)
+    @bar = @c.create(:name=>'bar', :i=>20)
+  end
+  after(:all) 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
+    @c[nil].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.with_pk(nil).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(:i=>10).with_pk(nil).should == nil
+    @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
+    @c.dataset.filter(:name=>'bar').with_pk(nil).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)
+    @foo.update(:i=>nil)
+    @c[@foo.id].should == @c.load(:id=>@foo.id, :name=>'foo3', :i=>nil)
+  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)
+    o = @c.create(:name=>nil, :i=>40)
+    @c[o.id].should == @c.load(:id=>o.id, :name=>nil, :i=>40)
+  end
+end
+
+describe "Caching plugins" do
+  before(:all) do
+    @db = INTEGRATION_DB
+    @db.drop_table?(:albums, :artists)
+    @db.create_table(:artists) do
+      primary_key :id
+    end
+    @db.create_table(:albums) do
+      primary_key :id
+      foreign_key :artist_id, :artists
+    end
+    @db[:artists].insert
+    @db[:albums].insert(:artist_id=>1)
+  end
+  before do
+    @Album = Class.new(Sequel::Model(@db[:albums]))
+    @Album.plugin :many_to_one_pk_lookup
+  end
+  after(:all) do
+    @db.drop_table?(:albums, :artists)
+  end
+
+  shared_examples_for "a caching plugin" do
+    it "should work with looking up using Model.[]" do 
+      @Artist[1].should equal(@Artist[1])
+      @Artist[:id=>1].should == @Artist[1]
+      @Artist[0].should == nil
+      @Artist[nil].should == nil
+    end
+
+    it "should work with lookup up many_to_one associated objects" do 
+      a = @Artist[1]
+      @Album.first.artist.should equal(a)
+    end
+  end
+
+  describe "caching plugin" do
+    before do
+      @cache_class = Class.new(Hash) do
+        def set(k, v, ttl) self[k] = v end
+        alias get []
+      end
+      @cache = @cache_class.new
+
+      @Artist = Class.new(Sequel::Model(@db[:artists]))
+      @Artist.plugin :caching, @cache
+      @Album.many_to_one :artist, :class=>@Artist
+    end
+
+    it_should_behave_like "a caching plugin"
+  end
+
+  describe "static_cache plugin" do
+    before do
+      @Artist = Class.new(Sequel::Model(@db[:artists]))
+      @Artist.plugin :static_cache
+      @Album.many_to_one :artist, :class=>@Artist
+    end
+
+    it_should_behave_like "a caching plugin"
+  end
+end
+
+describe "Sequel::Plugins::ConstraintValidations" do
+  before(:all) do
+    @db = INTEGRATION_DB
+    @db.extension(:constraint_validations)
+    @db.create_constraint_validations_table
+    @ds = @db[:cv_test]
+    @regexp = regexp = @db.dataset.supports_regexp?
+    @validate_block = proc do
+      presence :pre, :name=>:p
+      exact_length 5, :exactlen, :name=>:el
+      min_length 5, :minlen, :name=>:minl
+      max_length 5, :maxlen, :name=>:maxl
+      length_range 3..5, :lenrange, :name=>:lr
+      if regexp
+        format /^foo\d+/, :form, :name=>:f
+      end
+      like 'foo%', :lik, :name=>:l
+      ilike 'foo%', :ilik, :name=>:il
+      includes %w'abc def', :inc, :name=>:i
+      unique :uniq, :name=>:u
+      max_length 6, :minlen, :name=>:maxl2
+    end
+    @valid_row = {:pre=>'a', :exactlen=>'12345', :minlen=>'12345', :maxlen=>'12345', :lenrange=>'1234', :lik=>'fooabc', :ilik=>'FooABC', :inc=>'abc', :uniq=>'u'}
+    @violations = [
+      [:pre, [nil, '', ' ']],
+      [:exactlen, [nil, '', '1234', '123456']],
+      [:minlen, [nil, '', '1234']],
+      [:maxlen, [nil, '123456']],
+      [:lenrange, [nil, '', '12', '123456']],
+      [:lik, [nil, '', 'fo', 'fotabc', 'FOOABC']],
+      [:ilik, [nil, '', 'fo', 'fotabc']],
+      [:inc, [nil, '', 'ab', 'abcd']],
+    ]
+
+    if @regexp
+      @valid_row[:form] = 'foo1'
+      @violations << [:form, [nil, '', 'foo', 'fooa']]
+    end
+  end
+  after(:all) do
+    @db.drop_constraint_validations_table
+  end
+
+  shared_examples_for "constraint validations" do
+    cspecify "should set up constraints that work even outside the model", :mysql do 
+      proc{@ds.insert(@valid_row)}.should_not raise_error
+
+      # Test for unique constraint
+      proc{@ds.insert(@valid_row)}.should raise_error(Sequel::DatabaseError)
+
+      @ds.delete
+      @violations.each do |col, vals|
+        try = @valid_row.dup
+        vals += ['1234567'] if col == :minlen
+        vals.each do |val|
+          try[col] = val
+          proc{@ds.insert(try)}.should raise_error(Sequel::DatabaseError)
+        end
+      end
+
+      # Test for dropping of constraint
+      @db.alter_table(:cv_test){validate{drop :maxl2}}
+      proc{@ds.insert(@valid_row.merge(:minlen=>'1234567'))}.should_not raise_error
+    end
+
+    it "should set up automatic validations inside the model" do 
+      c = Class.new(Sequel::Model(@ds))
+      c.plugin :constraint_validations
+      c.delete
+      proc{c.create(@valid_row)}.should_not raise_error
+
+      # Test for unique validation 
+      c.new(@valid_row).should_not be_valid
+
+      c.delete
+      @violations.each do |col, vals|
+        try = @valid_row.dup
+        vals.each do |val|
+          try[col] = val
+          c.new(try).should_not be_valid
+        end
+      end
+    end
+  end
+
+  describe "via create_table" do
+    before(:all) do
+      regexp = @regexp
+      validate_block = @validate_block
+      @db.create_table!(:cv_test) do
+        primary_key :id
+        String :pre
+        String :exactlen
+        String :minlen
+        String :maxlen
+        String :lenrange
+        if regexp
+          String :form
+        end
+        String :lik
+        String :ilik
+        String :inc
+        String :uniq, :null=>false
+        validate(&validate_block)
+      end
+    end
+    after(:all) do
+      @db.drop_table?(:cv_test)
+      @db.drop_constraint_validations_for(:table=>:cv_test)
+    end
+
+    it_should_behave_like "constraint validations"
+  end
+
+  describe "via alter_table" do
+    before(:all) do
+      regexp = @regexp
+      validate_block = @validate_block
+      @db.create_table!(:cv_test) do
+        primary_key :id
+        String :lik
+        String :ilik
+        String :inc
+        String :uniq, :null=>false
+      end
+      @db.alter_table(:cv_test) do
+        add_column :pre, String
+        add_column :exactlen, String
+        add_column :minlen, String
+        add_column :maxlen, String
+        add_column :lenrange, String
+        if regexp
+          add_column :form, String
+        end
+        validate(&validate_block)
+      end
+    end
+    after(:all) do
+      @db.drop_table?(:cv_test)
+      @db.drop_constraint_validations_for(:table=>:cv_test)
+    end
+
+    it_should_behave_like "constraint validations"
+  end
+end