sequel 3.33.0 → 3.34.0

data/spec/extensions/association_dependencies_spec.rb

@@ -21,55 +21,55 @@ describe "AssociationDependencies plugin" do
   specify "should allow destroying associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:delete
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (artists.id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
   end
   
   specify "should allow destroying associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (position = 1)) LIMIT 1', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((albums.artist_id = 2) AND (position = 1)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow destroying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
   
   specify "should allow nullifying associated one_to_one objects" do
     @Artist.add_association_dependencies :first_album=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated many_to_many associations" do
     @Artist.add_association_dependencies :other_artists=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should raise an error if attempting to nullify a many_to_one association" do
@@ -97,21 +97,21 @@ describe "AssociationDependencies plugin" do
   specify "should allow specifying association dependencies in the plugin call" do
     @Album.plugin :association_dependencies, :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should work with subclasses" do
     c = Class.new(@Album)
     c.add_association_dependencies :artist=>:destroy
     c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1']
 
     @Album.add_association_dependencies :artist=>:destroy
     c2 = Class.new(@Album)
     c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 end

data/spec/extensions/caching_spec.rb

@@ -82,7 +82,7 @@ describe Sequel::Model, "caching" do
     Class.new(@c).cache_ttl.should == 1234
   end
   
-  it "should generate a cache key appropriate to the class" do
+  it "should generate a cache key appropriate to the class via the Model#cache_key" do
     m = @c.new
     m.values[:id] = 1
     m.cache_key.should == "#{m.class}:1"
@@ -114,6 +114,11 @@ describe Sequel::Model, "caching" do
     m.values[:b] = 789
     m.cache_key.should == "#{m.class}:123,789,456"
   end
+
+  it "should generate a cache key via the Model.cache_key method" do
+    @c.cache_key(1).should == "#{@c}:1"
+    @c.cache_key([1, 2]).should == "#{@c}:1,2"
+  end
   
   it "should raise error if attempting to generate cache_key and primary key value is null" do
     m = @c.new
@@ -156,6 +161,11 @@ describe Sequel::Model, "caching" do
     m2.should == m
     m2.values.should == {:name=>"sharon", :id=>1}
   end
+
+  it "should handle lookups by nil primary keys" do
+    @c[nil].should == nil
+    @c.db.sqls.should == []
+  end
   
   it "should delete the cache when writing to the database" do
     m = @c[1]
@@ -178,13 +188,13 @@ describe Sequel::Model, "caching" do
     @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE (id = 1)"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
 
     m = @c2[1]
     @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
-    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE (id = 1)"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
   end
   
   it "should support #[] as a shortcut to #find with hash" do
@@ -220,4 +230,17 @@ describe Sequel::Model, "caching" do
   it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
     @c4[1].values.should == {:name => 'sharon', :id => 1}
   end
+  
+  it "should support Model.cache_get_pk for getting a value from the cache by primary key" do
+    @c.cache_get_pk(1).should == nil
+    m = @c[1]
+    @c.cache_get_pk(1).should == m
+  end
+  
+  it "should support Model.cache_delete_pk for removing a value from the cache by primary key" do
+    @c[1]
+    @c.cache_get_pk(1).should_not == nil
+    @c.cache_delete_pk(1).should == nil
+    @c.cache_get_pk(1).should == nil
+  end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -130,10 +130,10 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should lazily load attributes for columns in subclass tables" do
-    Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
+    Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
     m = Manager[1]
     @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 1) LIMIT 1']
-    Executive.dataset._fetch = {:num_managers=>3}
+    Executive.instance_dataset._fetch = Executive.dataset._fetch = {:num_managers=>3}
     m.num_managers.should == 3
     @db.sqls.should == ['SELECT num_managers FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id) WHERE (id = 1) LIMIT 1']
     m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}

data/spec/{core/core_sql_spec.rb → extensions/core_extensions_spec.rb}

@@ -1,5 +1,23 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
+describe "Sequel core extensions" do
+  specify "should not be used inside Sequel, to insure Sequel works without them" do
+    usage = []
+    match_re = /(\.(all_two_pairs\?|sql_value_list|sql_array|sql_expr|sql_negate|sql_or|sql_string_join|lit|to_sequel_blob|case|sql_expr_if_all_two_pairs)\W)|:\w+\.(qualify|identifier|as|cast|asc|desc|sql_subscript|\*|sql_function)\W/
+    comment_re = /^\s*#|# core_sql/
+    Dir['lib/sequel/**/*.rb'].each do |f|
+      lines = File.read(f).split("\n").grep(match_re).delete_if{|l| l =~ comment_re}
+      usage << [f, lines] unless lines.empty?
+    end
+    puts usage unless usage.empty?
+    usage.should be_empty
+  end
+
+  specify "should have Sequel.core_extensions? be true if enabled" do
+    Sequel.core_extensions?.should be_true
+  end
+end
+
 describe "Array#all_two_pairs?" do
   specify "should return false if empty" do
     [].all_two_pairs?.should == false
@@ -285,41 +303,11 @@ describe "Symbol" do
     @oe.class.should == Sequel::SQL::OrderedExpression
     @oe.descending.should == false
   end
-end
-
-describe "Dataset#literal" do
-  before do
-    @ds = Sequel::Database.new.dataset
-  end
-  
-  specify "should convert qualified symbol notation into dot notation" do
-    @ds.literal(:abc__def).should == 'abc.def'
-  end
-  
-  specify "should convert AS symbol notation into SQL AS notation" do
-    @ds.literal(:xyz___x).should == 'xyz AS x'
-    @ds.literal(:abc__def___x).should == 'abc.def AS x'
-  end
-  
-  specify "should support names with digits" do
-    @ds.literal(:abc2).should == 'abc2'
-    @ds.literal(:xx__yy3).should == 'xx.yy3'
-    @ds.literal(:ab34__temp3_4ax).should == 'ab34.temp3_4ax'
-    @ds.literal(:x1___y2).should == 'x1 AS y2'
-    @ds.literal(:abc2__def3___ggg4).should == 'abc2.def3 AS ggg4'
-  end
-  
-  specify "should support upper case and lower case" do
-    @ds.literal(:ABC).should == 'ABC'
-    @ds.literal(:Zvashtoy__aBcD).should == 'Zvashtoy.aBcD'
-  end
 
-  specify "should support spaces inside column names" do
-    @ds.quote_identifiers = true
-    @ds.literal(:"AB C").should == '"AB C"'
-    @ds.literal(:"Zvas htoy__aB cD").should == '"Zvas htoy"."aB cD"'
-    @ds.literal(:"aB cD___XX XX").should == '"aB cD" AS "XX XX"'
-    @ds.literal(:"Zva shtoy__aB cD___XX XX").should == '"Zva shtoy"."aB cD" AS "XX XX"'
+  specify "should work correctly with objects" do
+    o = Object.new
+    def o.sql_literal(ds) "(foo)" end
+    @ds.literal(:column.qualify(o)).should == '(foo)."COLUMN"'
   end
 end
 
@@ -341,6 +329,7 @@ describe "Symbol" do
     @ds.literal(:abc.sql_subscript(1)).should == "abc[1]"
     @ds.literal(:abc__def.sql_subscript(1)).should == "abc.def[1]"
     @ds.literal(:abc.sql_subscript(1)|2).should == "abc[1, 2]"
+    @ds.literal(:abc.sql_subscript(1)[2]).should == "abc[1][2]"
   end
 
   specify "should support cast_numeric and cast_string" do
@@ -380,63 +369,3 @@ describe "Symbol" do
     :abc.extract(:year).to_s(@ds).should == "extract(year FROM abc)"
   end
 end
-
-describe "Sequel::SQL::Function#==" do
-  specify "should be true for functions with the same name and arguments, false otherwise" do
-    a = :date.sql_function(:t)
-    b = :date.sql_function(:t)
-    a.should == b
-    (a == b).should == true
-    c = :date.sql_function(:c)
-    a.should_not == c
-    (a == c).should == false
-    d = :time.sql_function(:c)
-    a.should_not == d
-    c.should_not == d
-    (a == d).should == false
-    (c == d).should == false
-  end
-end
-
-describe "Sequel::SQL::OrderedExpression" do
-  specify "should #desc" do
-    @oe = :column.asc
-    @oe.descending.should == false
-    @oe.desc.descending.should == true
-  end
-
-  specify "should #asc" do
-    @oe = :column.desc
-    @oe.descending.should == true
-    @oe.asc.descending.should == false
-  end
-
-  specify "should #invert" do
-    @oe = :column.desc
-    @oe.invert.descending.should == false
-    @oe.invert.invert.descending.should == true
-  end
-end
-
-describe "Expression" do
-  specify "should consider objects == only if they have the same attributes" do
-    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc
-    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc
-
-    :column.qualify(:table).cast(:type).*(:numeric_column).asc.should eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
-    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.should_not eql(:column.qualify(:table).cast(:type).*(:numeric_column).asc)
-  end
-
-  specify "should use the same hash value for objects that have the same attributes" do
-    :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
-    :other_column.qualify(:table).cast(:type).*(:numeric_column).asc.hash.should_not == :column.qualify(:table).cast(:type).*(:numeric_column).asc.hash
-
-    h = {}
-    a = :column.qualify(:table).cast(:type).*(:numeric_column).asc
-    b = :column.qualify(:table).cast(:type).*(:numeric_column).asc
-    h[a] = 1
-    h[b] = 2
-    h[a].should == 2
-    h[b].should == 2
-  end
-end

data/spec/extensions/force_encoding_spec.rb

@@ -74,12 +74,13 @@ describe "force_encoding plugin" do
   
   specify "should work when saving new model instances" do
     o = @c.new
-    @c.dataset = ds = MODEL_DB[:a]
+    ds = MODEL_DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
       {:id=>1, :x=>s}
     end
+    @c.dataset = ds
     o.save
     o.x.should == 'blah'
     o.x.encoding.should == @e1
@@ -87,12 +88,13 @@ describe "force_encoding plugin" do
   
   specify "should work when refreshing model instances" do
     o = @c.load(:id=>1, :x=>'as')
-    @c.dataset = ds = MODEL_DB[:a]
+    ds = MODEL_DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
       {:id=>1, :x=>s}
     end
+    @c.dataset = ds
     o.refresh
     o.x.should == 'blah'
     o.x.encoding.should == @e1

data/spec/extensions/hook_class_methods_spec.rb

@@ -308,7 +308,7 @@ describe "Model#before_destroy && Model#after_destroy" do
     @c.before_destroy {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.destroy
-    MODEL_DB.sqls.should == ['BLAH before', "DELETE FROM items WHERE (id = 2233)", 'BLAH after']
+    MODEL_DB.sqls.should == ['BLAH before', "DELETE FROM items WHERE id = 2233", 'BLAH after']
   end
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
@@ -402,7 +402,7 @@ end
 
 describe "Model#add_hook_type" do
   before do
-    class Foo < Sequel::Model(:items)
+    class ::Foo < Sequel::Model(:items)
       add_hook_type :before_bar, :after_bar
 
       def bar
@@ -413,6 +413,9 @@ describe "Model#add_hook_type" do
     end
     @f = Class.new(Foo)
   end
+  after do
+    Object.send(:remove_const, :Foo)
+  end
 
   specify "should have before_bar and after_bar class methods" do
     @f.should respond_to(:before_bar)

data/spec/extensions/identity_map_spec.rb

@@ -218,6 +218,23 @@ describe "Sequel::Plugins::IdentityMap" do
     end
   end
 
+  it "should not use the identity map as a lookup cache if a dynamic callback is used" do
+    @c1.many_to_one :artist, :class=>@c2
+    @c.with_identity_map do
+      MODEL_DB.sqls.length.should == 0
+      o = @c1.load(:id=>1, :artist_id=>2)
+      a = o.artist
+      a.should be_a_kind_of(@c2)
+      MODEL_DB.sqls.length.should == 1
+      o = @c1.load(:id=>2, :artist_id=>2)
+      o.artist.should == a
+      MODEL_DB.sqls.length.should == 0
+      o = @c1.load(:id=>3, :artist_id=>3)
+      o.artist.should_not == a
+      MODEL_DB.sqls.length.should == 1
+    end
+  end
+
   it "should not override custom :eager_loaders for many_to_many associations" do
     @c1.columns :id
     @c2.columns :id

data/spec/extensions/instance_filters_spec.rb

@@ -21,7 +21,7 @@ describe "instance_filters plugin" do
 
   specify "should raise an error when destroying a stale record" do
     @p.destroy
-    MODEL_DB.sqls.should == ["DELETE FROM people WHERE (id = 1)"]
+    MODEL_DB.sqls.should == ["DELETE FROM people WHERE id = 1"]
     @p.instance_filter(:name=>'Jim')
     @p.this.numrows = 0
     proc{@p.destroy}.should raise_error(Sequel::Plugins::InstanceFilters::Error)

data/spec/extensions/lazy_attributes_spec.rb

@@ -11,7 +11,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       meta_def(:columns){[:id, :name]}
       lazy_attributes :name
       meta_def(:columns){[:id]}
-      dataset._fetch = proc do |sql|
+      instance_dataset._fetch = dataset._fetch = proc do |sql|
         if sql !~ /WHERE/
           if sql =~ /name/
             [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
@@ -133,7 +133,7 @@ describe "Sequel::Plugins::LazyAttributes" do
 
   it "should work with the serialization plugin" do
     @c.plugin :serialization, :yaml, :name
-    @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]]
+    @c.instance_dataset._fetch = @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]]
     @c.with_identity_map do
       ms = @ds.all
       ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]

data/spec/extensions/list_spec.rb

@@ -76,8 +76,8 @@ describe "List plugin" do
   end
 
   it "should have position field set to max+1 when creating if not already set" do
-    @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]]
-    @c.dataset.autoid = 1
+    @c.instance_dataset._fetch = @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]]
+    @c.instance_dataset.autoid = @c.dataset.autoid = 1
     @c.create.values.should == {:id=>1, :position=>1}
     @c.create.values.should == {:id=>2, :position=>2}
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -89,8 +89,8 @@ describe "List plugin" do
   end
 
   it "should have position field set to max+1 in scope when creating if not already set" do
-    @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]]
-    @sc.dataset.autoid = 1
+    @sc.instance_dataset._fetch = @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]]
+    @sc.instance_dataset.autoid = @sc.dataset.autoid = 1
     @sc.create(:scope_id=>1).values.should == {:id=>1, :scope_id=>1, :position=>1}
     @sc.create(:scope_id=>1).values.should == {:id=>2, :scope_id=>1, :position=>2}
     @sc.create(:scope_id=>2).values.should == {:id=>3, :scope_id=>2, :position=>1}

data/spec/extensions/many_to_one_pk_lookup_spec.rb

@@ -0,0 +1,140 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::ManyToOnePkLookup" do
+  before do
+    class ::LookupModel < ::Sequel::Model
+      plugin :many_to_one_pk_lookup
+      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
+      columns :id, :id2
+    end
+    @cc = CachingModel
+
+    @db = MODEL_DB
+  end
+  after do
+    Object.send(:remove_const, :CachingModel)
+    Object.send(:remove_const, :LookupModel)
+  end
+
+  shared_examples_for "many_to_one_pk_lookup with composite keys" do
+    it "should use a simple primary key lookup when retrieving many_to_one associated records" do
+      @db.sqls.should == []
+      @c.load(:id=>3, :caching_model_id=>1, :caching_model_id2=>2).caching_model2.should equal(@cm12)
+      @c.load(:id=>3, :caching_model_id=>2, :caching_model_id2=>1).caching_model2.should equal(@cm21)
+      @db.sqls.should == []
+      @c.load(:id=>4, :caching_model_id=>2, :caching_model_id2=>2).caching_model2
+      @db.sqls.should_not == []
+    end
+  end
+
+  shared_examples_for "many_to_one_pk_lookup" do
+    it "should use a simple primary key lookup when retrieving many_to_one associated records via a composite key" do
+      @cc.set_primary_key([:id, :id2])
+      @db.sqls.should == []
+      @c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
+      @c.load(:id=>4, :caching_model_id=>2).caching_model.should equal(@cm2)
+      @db.sqls.should == []
+      @c.load(:id=>4, :caching_model_id=>3).caching_model
+      @db.sqls.should_not == []
+    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.should_not == []
+    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.should_not == []
+    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.should_not == []
+    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(:not_caching_model))
+      c2.dataset._fetch = {:id=>1}
+      c = Class.new(Sequel::Model(:lookup_model))
+      c.class_eval do
+        plugin :prepared_statements_associations
+        plugin :many_to_one_pk_lookup
+        columns :id, :caching_model_id
+        many_to_one :caching_model, :class=>c2
+      end
+      c.load(:id=>3, :caching_model_id=>1).caching_model.should == c2.load(:id=>1)
+      @db.sqls.should_not == []
+    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
+        plugin :many_to_one_pk_lookup
+        columns :id, :caching_model_id
+        many_to_one :caching_model
+      end
+      c.load(:id=>3, :caching_model_id=>1).caching_model.should equal(@cm1)
+      @db.sqls.should == []
+    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
+      @cc.dataset._fetch = {:id=>1}
+      @cm1 = @cc[1]
+      @cm2 = @cc[2]
+      @cm12 = @cc[1, 2]
+      @cm21 = @cc[2, 1]
+
+      @db.reset
+    end
+
+    it_should_behave_like "many_to_one_pk_lookup"
+    it_should_behave_like "many_to_one_pk_lookup with composite keys"
+  end
+
+  describe "With static_cache plugin with single key" do
+    before do
+      @cc.dataset._fetch = [{:id=>1}, {:id=>2}]
+      @cc.plugin :static_cache
+      @cm1 = @cc[1]
+      @cm2 = @cc[2]
+      @db.reset
+    end
+
+    it_should_behave_like "many_to_one_pk_lookup"
+  end
+
+  describe "With static_cache plugin with composite key" do
+    before do
+      @cc.set_primary_key([:id, :id2])
+      @cc.dataset._fetch = [{:id=>1, :id2=>2}, {:id=>2, :id2=>1}]
+      @cc.plugin :static_cache
+      @cm12 = @cc[[1, 2]]
+      @cm21 = @cc[[2, 1]]
+      @db.reset
+    end
+
+    it_should_behave_like "many_to_one_pk_lookup with composite keys"
+  end
+end