sequel 4.26.0 → 5.37.0

data/spec/extensions/server_block_spec.rb

@@ -1,90 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-with_server_specs = shared_description do
-  it "should set the default server to use in the block" do
-    @db.with_server(:a){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- a"]
-    @db.with_server(:b){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-  end
-
-  it "should have no affect after the block" do
-    @db.with_server(:a){@db[:t].all}
-    @db.sqls.must_equal ["SELECT * FROM t -- a"]
-    @db[:t].all
-    @db.sqls.must_equal ["SELECT * FROM t"]
-  end
-
-  it "should not override specific server inside the block" do
-    @db.with_server(:a){@db[:t].server(:b).all}
-    @db.sqls.must_equal ["SELECT * FROM t -- b"]
-  end
-
-  it "should work correctly when blocks are nested" do
-    @db[:t].all
-    @db.with_server(:a) do
-      @db[:t].all
-      @db.with_server(:b){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t"]
-  end
-
-  it "should work correctly for inserts/updates/deletes" do
-    @db.with_server(:a) do
-      @db[:t].insert
-      @db[:t].update(:a=>1)
-      @db[:t].delete
-    end
-    @db.sqls.must_equal ["INSERT INTO t DEFAULT VALUES -- a", "UPDATE t SET a = 1 -- a", "DELETE FROM t -- a"]
-  end
-end
-
-describe "Database#with_server single threaded" do
-  before do
-    @db = Sequel.mock(:single_threaded=>true, :servers=>{:a=>{}, :b=>{}})
-    @db.extension :server_block
-  end
-
-  include with_server_specs
-end
-
-describe "Database#with_server multi threaded" do
-  before do
-    @db = Sequel.mock(:servers=>{:a=>{}, :b=>{}, :c=>{}, :d=>{}})
-    @db.extension :server_block
-  end
-
-  include with_server_specs
-
-  it "should respect multithreaded access" do
-    q, q1 = Queue.new, Queue.new
-    
-    t = nil
-    @db[:t].all
-    @db.with_server(:a) do
-      @db[:t].all
-      t = Thread.new do
-        @db[:t].all
-        @db.with_server(:c) do
-          @db[:t].all
-          @db.with_server(:d){@db[:t].all}
-          q.push nil
-          q1.pop
-          @db[:t].all
-        end
-        @db[:t].all
-      end
-      q.pop
-      @db.with_server(:b){@db[:t].all}
-      @db[:t].all
-    end
-    @db[:t].all
-    q1.push nil
-    t.join
-    @db.sqls.must_equal ["SELECT * FROM t", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t -- d",
-      "SELECT * FROM t -- b", "SELECT * FROM t -- a", "SELECT * FROM t", "SELECT * FROM t -- c", "SELECT * FROM t"]
-  end
-end
-

data/spec/extensions/set_overrides_spec.rb

@@ -1,61 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Dataset #set_defaults" do
-  before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_defaults(:x=>1)
-  end
-
-  it "should set the default values for inserts" do
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:x=>2).must_equal "INSERT INTO items (x) VALUES (2)"
-    @ds.insert_sql(:y=>2).must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_defaults(:y=>2).insert_sql.must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_defaults(:x=>2).insert_sql.must_equal "INSERT INTO items (x) VALUES (2)"
-  end
-
-  it "should set the default values for updates" do
-    @ds.update_sql.must_equal "UPDATE items SET x = 1"
-    @ds.update_sql(:x=>2).must_equal "UPDATE items SET x = 2"
-    @ds.update_sql(:y=>2).must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_defaults(:y=>2).update_sql.must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_defaults(:x=>2).update_sql.must_equal "UPDATE items SET x = 2"
-  end
-
-  it "should not affect String update arguments" do
-    @ds.update_sql('y = 2').must_equal "UPDATE items SET y = 2"
-  end
-
-  it "should have working mutation method" do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
-    @ds.set_defaults!(:x=>1)
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-  end
-end
-
-describe "Sequel::Dataset #set_overrides" do
-  before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides).set_overrides(:x=>1)
-  end
-
-  it "should override the given values for inserts" do
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:x=>2).must_equal "INSERT INTO items (x) VALUES (1)"
-    @ds.insert_sql(:y=>2).must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_overrides(:y=>2).insert_sql.must_match(/INSERT INTO items \([xy], [xy]\) VALUES \([21], [21]\)/)
-    @ds.set_overrides(:x=>2).insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-  end
-
-  it "should override the given values for updates" do
-    @ds.update_sql.must_equal "UPDATE items SET x = 1"
-    @ds.update_sql(:x=>2).must_equal "UPDATE items SET x = 1"
-    @ds.update_sql(:y=>2).must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_overrides(:y=>2).update_sql.must_match(/UPDATE items SET (x = 1|y = 2), (x = 1|y = 2)/)
-    @ds.set_overrides(:x=>2).update_sql.must_equal "UPDATE items SET x = 1"
-  end
-
-  it "should have working mutation method" do
-    @ds = Sequel.mock.dataset.from(:items).extension(:set_overrides)
-    @ds.set_overrides!(:x=>1)
-    @ds.insert_sql.must_equal "INSERT INTO items (x) VALUES (1)"
-  end
-end

data/spec/extensions/sharding_spec.rb

@@ -1,198 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "sharding plugin" do
-  before do
-    @db = Sequel.mock(:numrows=>1, :autoid=>proc{1}, :servers=>{:s1=>{}, :s2=>{}, :s3=>{}, :s4=>{}})
-    @Artist = Class.new(Sequel::Model(@db[:artists]))
-    @Artist.class_eval do
-      instance_dataset._fetch = dataset._fetch = {:id=>2, :name=>'YJM'}
-      columns :id, :name
-      plugin :sharding
-    end
-    @Album = Class.new(Sequel::Model(@db[:albums]))
-    @Album.class_eval do
-      instance_dataset._fetch = dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
-      columns :id, :artist_id, :name
-      plugin :sharding
-    end
-    @Tag = Class.new(Sequel::Model(@db[:tags]))
-    @Tag.class_eval do
-      instance_dataset._fetch = dataset._fetch = {:id=>3, :name=>'M'}
-      columns :id, :name
-      plugin :sharding
-    end
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Album.many_to_one :artist, :class=>@Artist
-    @Album.many_to_many :tags, :class=>@Tag, :left_key=>:album_id, :right_key=>:tag_id, :join_table=>:albums_tags
-    @db.sqls
-  end 
-
-  it "should allow you to instantiate a new object for a specified shard" do
-    @Album.new_using_server(:s1, :name=>'RF').save
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
-    
-    @Album.new_using_server(:s2){|o| o.name = 'MO'}.save
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-  end 
-
-  it "should allow you to create and save a new object for a specified shard" do
-    @Album.create_using_server(:s1, :name=>'RF')
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('RF') -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
-
-    @Album.create_using_server(:s2){|o| o.name = 'MO'}
-    @db.sqls.must_equal ["INSERT INTO albums (name) VALUES ('MO') -- s2", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-  end 
-
-  it "should have objects retrieved from a specific shard update that shard" do
-    @Album.server(:s1).first.update(:name=>'MO')
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s1"]
-  end 
-
-  it "should have objects retrieved from a specific shard delete from that shard" do
-    @Album.server(:s1).first.delete
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "DELETE FROM albums WHERE (id = 1) -- s1"]
-  end 
-
-  it "should have objects retrieved from a specific shard reload from that shard" do
-    @Album.server(:s1).first.reload
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s1"]
-  end 
-
-  it "should use current dataset's shard when eager loading if eagerly loaded dataset doesn't have its own shard" do
-    albums = @Album.server(:s1).eager(:artist).all
-    @db.sqls.must_equal ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s1"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
-  end 
-
-  it "should not use current dataset's shard when eager loading if eagerly loaded dataset has its own shard" do
-    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
-    albums = @Album.server(:s1).eager(:artist).all
-    @db.sqls.must_equal ["SELECT * FROM albums -- s1", "SELECT * FROM artists WHERE (artists.id IN (2)) -- s2"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
-  end 
-
-  it "should use current dataset's shard when eager graphing if eagerly graphed dataset doesn't have its own shard" do
-    ds = @Album.server(:s1).eager_graph(:artist)
-    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
-    albums = ds.all
-    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s1"]
-  end 
-
-  it "should not use current dataset's shard when eager graphing if eagerly graphed dataset has its own shard" do
-    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
-    ds = @Album.server(:s1).eager_graph(:artist)
-    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
-    albums = ds.all
-    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id) -- s1"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
-  end 
-
-  it "should use eagerly graphed dataset shard for eagerly graphed objects even if current dataset does not have a shard" do
-    @Artist.instance_dataset.opts[:server] = @Artist.dataset.opts[:server] = :s2
-    ds = @Album.eager_graph(:artist)
-    ds._fetch = {:id=>1, :artist_id=>2, :name=>'RF', :artist_id_0=>2, :artist_name=>'YJM'}
-    albums = ds.all
-    @db.sqls.must_equal ["SELECT albums.id, albums.artist_id, albums.name, artist.id AS artist_id_0, artist.name AS artist_name FROM albums LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)"]
-    albums.length.must_equal 1
-    albums.first.artist.save
-    @db.sqls.must_equal ["UPDATE artists SET name = 'YJM' WHERE (id = 2) -- s2"]
-  end 
-
-  it "should have objects retrieved from a specific shard use associated objects from that shard, with modifications to the associated objects using that shard" do
-    album = @Album.server(:s1).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1"]
-    album.artist.update(:name=>'AS')
-    @db.sqls.must_equal ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- s1", "UPDATE artists SET name = 'AS' WHERE (id = 2) -- s1"]
-    album.tags.map{|a| a.update(:name=>'SR')}
-    @db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (albums_tags.album_id = 1) -- s1", "UPDATE tags SET name = 'SR' WHERE (id = 3) -- s1"]
-    @Artist.server(:s2).first.albums.map{|a| a.update(:name=>'MO')}
-    @db.sqls.must_equal ["SELECT * FROM artists LIMIT 1 -- s2", "SELECT * FROM albums WHERE (albums.artist_id = 2) -- s2", "UPDATE albums SET name = 'MO' WHERE (id = 1) -- s2"]
-  end 
-
-  it "should have objects retrieved from a specific shard add associated objects to that shard" do
-    album = @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.add_album(:name=>'MO')
-    sqls = @db.sqls
-    ["INSERT INTO albums (artist_id, name) VALUES (2, 'MO') -- s2", "INSERT INTO albums (name, artist_id) VALUES ('MO', 2) -- s2"].must_include(sqls.shift)
-    sqls.must_equal ["SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-    
-    album.add_tag(:name=>'SR')
-    sqls = @db.sqls
-    ["INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3) -- s1", "INSERT INTO albums_tags (tag_id, album_id) VALUES (3, 1) -- s1"].must_include(sqls.pop)
-    sqls.must_equal ["INSERT INTO tags (name) VALUES ('SR') -- s1", "SELECT * FROM tags WHERE (id = 1) LIMIT 1 -- s1", ]
-  end 
-
-  it "should have objects retrieved from a specific shard remove associated objects from that shard" do
-    album = @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.remove_album(1)
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = NULL, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = NULL WHERE (id = 1) -- s2"].must_include(sqls.pop)
-    sqls.must_equal ["SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (albums.id = 1)) LIMIT 1 -- s2"]
-    
-    album.remove_tag(3)
-    @db.sqls.must_equal ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE ((albums_tags.album_id = 1) AND (tags.id = 3)) LIMIT 1 -- s1", "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id = 3)) -- s1"]
-  end 
-
-  it "should have objects retrieved from a specific shard remove all associated objects from that shard" do
-    album = @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.remove_all_albums
-    @db.sqls.must_equal ["UPDATE albums SET artist_id = NULL WHERE (artist_id = 2) -- s2"]
-    
-    album.remove_all_tags
-    @db.sqls.must_equal ["DELETE FROM albums_tags WHERE (album_id = 1) -- s1"]
-  end 
-
-  it "should not override a server already set on an associated object" do
-    @Album.server(:s1).first
-    artist = @Artist.server(:s2).first
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM artists LIMIT 1 -- s2"]
-
-    artist.add_album(@Album.load(:id=>4, :name=>'MO').set_server(:s3))
-    ["UPDATE albums SET artist_id = 2, name = 'MO' WHERE (id = 4) -- s3", "UPDATE albums SET name = 'MO', artist_id = 2 WHERE (id = 4) -- s3"].must_include(@db.sqls.pop)
-
-    artist.remove_album(@Album.load(:id=>5, :name=>'T', :artist_id=>2).set_server(:s4))
-    # Should select from current object's shard to check existing association, but update associated object's shard
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = NULL, name = 'T' WHERE (id = 5) -- s4", "UPDATE albums SET name = 'T', artist_id = NULL WHERE (id = 5) -- s4"].must_include(sqls.pop)
-    sqls.must_equal ["SELECT 1 AS one FROM albums WHERE ((albums.artist_id = 2) AND (id = 5)) LIMIT 1 -- s2"]
-  end 
-
-  it "should be able to set a shard to use for any object using set_server" do
-    @Album.server(:s1).first.set_server(:s2).reload
-    @db.sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s1", "SELECT * FROM albums WHERE (id = 1) LIMIT 1 -- s2"]
-  end 
-
-  it "should use transactions on the correct shard" do
-    @Album.use_transactions = true
-    @Album.server(:s2).first.save
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s2", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s2"].must_include(sqls.slice!(2))
-    sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s2", "COMMIT -- s2"]
-  end 
-
-  it "should use override current shard when saving with given :server option" do
-    @Album.use_transactions = true
-    @Album.server(:s2).first.save(:server=>:s1)
-    sqls = @db.sqls
-    ["UPDATE albums SET artist_id = 2, name = 'RF' WHERE (id = 1) -- s1", "UPDATE albums SET name = 'RF', artist_id = 2 WHERE (id = 1) -- s1"].must_include(sqls.slice!(2))
-    sqls.must_equal ["SELECT * FROM albums LIMIT 1 -- s2", "BEGIN -- s1", "COMMIT -- s1"]
-  end 
-end

data/spec/extensions/shared_caching_spec.rb

@@ -1,175 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Shared caching behavior" do
-  before do
-    @db = Sequel.mock
-
-    class ::LookupModel < ::Sequel::Model(@db)
-      columns :id, :caching_model_id, :caching_model_id2
-      many_to_one :caching_model
-      many_to_one :caching_model2, :key=>[:caching_model_id, :caching_model_id2], :class=>:CachingModel
-    end
-    @c = LookupModel
-
-    class ::CachingModel < Sequel::Model(@db)
-      columns :id, :id2
-    end
-    @cc = CachingModel
-  end
-  after do
-    Object.send(:remove_const, :CachingModel)
-    Object.send(:remove_const, :LookupModel)
-  end
-
-  many_to_one_cpk_specs = shared_description do
-    it "should use a simple primary key lookup when retrieving many_to_one associated records with a composite key" do
-      @db.sqls.must_equal []
-      @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.must_be_same_as(@cm12)
-      @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.must_be_same_as(@cm21)
-      @db.sqls.must_equal []
-      @db.fetch = []
-      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2.must_equal nil
-    end
-  end
-
-  many_to_one_pk_specs = shared_description do
-    it "should use a simple primary key lookup when retrieving many_to_one associated records" do
-      @cc.set_primary_key([:id, :id2])
-      @db.sqls.must_equal []
-      @c.load(:id=>3, :caching_model_id=>1).caching_model.must_be_same_as(@cm1)
-      @c.load(:id=>4, :caching_model_id=>2).caching_model.must_be_same_as(@cm2)
-      @db.sqls.must_equal []
-      @db.fetch = []
-      @c.load(:id=>4, :caching_model_id=>3).caching_model.must_equal nil
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a nil :key option" do
-      @c.many_to_one :caching_model, :key=>nil, :dataset=>proc{CachingModel.filter(:caching_model_id=>caching_model_id)}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a nil :key option" do
-      @c.many_to_one :caching_model, :many_to_one_pk_lookup=>false
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation's :primary_key option doesn't match the primary key of the associated class" do
-      @c.many_to_one :caching_model, :primary_key=>:id2
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has :conditions" do
-      @c.many_to_one :caching_model, :conditions=>{:a=>1}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has :select" do
-      @c.many_to_one :caching_model, :select=>[:a, :b]
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a block" do
-      @c.many_to_one(:caching_model){|ds| ds.where{a > 1}}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should not use a simple primary key lookup if the assocation has a non-default :dataset option" do
-      cc = @cc
-      @c.many_to_one :caching_model, :dataset=>proc{cc.where(:id=>caching_model_id)}
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.wont_equal []
-    end
-
-    it "should use a simple primary key lookup if explicitly set" do
-      @c.many_to_one :caching_model, :select=>[:a, :b], :many_to_one_pk_lookup=>true
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.must_equal []
-    end
-
-    it "should not use a simple primary key lookup if the prepared_statements_associations method is being used" do
-      c2 = Class.new(Sequel::Model(@db[:not_caching_model]))
-      c2.dataset._fetch = {:id=>1}
-      c = Class.new(Sequel::Model(@db[:lookup_model]))
-      c.class_eval do
-        plugin :prepared_statements_associations
-        columns :id, :caching_model_id
-        many_to_one :caching_model, :class=>c2
-      end
-      c.load(:id=>3, :caching_model_id=>1).caching_model.must_equal c2.load(:id=>1)
-      @db.sqls.wont_equal []
-    end
-
-    it "should use a simple primary key lookup if the prepared_statements_associations method is being used but associated model also uses caching" do
-      c = Class.new(Sequel::Model(:lookup_model))
-      c.class_eval do
-        plugin :prepared_statements_associations
-        columns :id, :caching_model_id
-        many_to_one :caching_model
-      end
-      c.load(:id=>3, :caching_model_id=>1).caching_model.must_be_same_as(@cm1)
-      @db.sqls.must_equal []
-    end
-  end
-
-  describe "With caching plugin" do
-    before do
-      @cache_class = Class.new(Hash) do
-        attr_accessor :ttl
-        def set(k, v, ttl); self[k] = v; @ttl = ttl; end
-        def get(k); self[k]; end
-      end
-      cache = @cache_class.new
-      @cache = cache
-      
-      @cc.plugin :caching, @cache
-      @db.fetch = {:id=>1}
-      @cm1 = @cc[1]
-      @cm2 = @cc[2]
-      @cm12 = @cc[1, 2]
-      @cm21 = @cc[2, 1]
-
-      @db.sqls
-    end
-
-    include many_to_one_cpk_specs
-    include many_to_one_pk_specs
-  end
-
-  describe "With static_cache plugin with single key" do
-    before do
-      @db.fetch = [{:id=>1}, {:id=>2}]
-      @cc.plugin :static_cache
-      @cm1 = @cc[1]
-      @cm2 = @cc[2]
-      @db.sqls
-    end
-
-    include many_to_one_pk_specs
-
-    it "should not issue regular query if primary key lookup returns no rows" do
-      def @cc.primary_key_lookup(pk); end
-      @c.many_to_one :caching_model
-      @c.load(:id=>3, :caching_model_id=>1).caching_model
-      @db.sqls.must_equal []
-    end
-  end
-
-  describe "With static_cache plugin with composite key" do
-    before do
-      @cc.set_primary_key([:id, :id2])
-      @db.fetch = [{:id=>1, :id2=>2}, {:id=>2, :id2=>1}]
-      @cc.plugin :static_cache
-      @cm12 = @cc[[1, 2]]
-      @cm21 = @cc[[2, 1]]
-      @db.sqls
-    end
-
-    include many_to_one_cpk_specs
-  end
-end