sequel 3.48.0 → 4.0.0

data/lib/sequel/plugins/identity_map.rb

@@ -1,260 +0,0 @@
-module Sequel
-  module Plugins
-    # The identity_map plugin allows the user to create temporary identity maps
-    # via the with_identity_map method, which takes a block.  Inside the block,
-    # objects have a 1-1 correspondence with rows in the database.
-    #
-    # For example, the following is true, and wouldn't be true if you weren't
-    # using the identity map:
-    #   Sequel::Model.with_identity_map do
-    #     Album.filter{(id > 0) & (id < 2)}.first.object_id == Album.first(:id=>1).object_id
-    #   end
-    #
-    # In addition to providing a 1-1 correspondence, the identity_map plugin
-    # also provides a cached looked up of records in two cases:
-    # * Model.[] (e.g. Album[1])
-    # * Model.many_to_one accessor methods (e.g. album.artist)
-    #
-    # If the object you are looking up, using one of those two methods, is already
-    # in the identity map, the record is returned without a database query being
-    # issued.
-    #
-    # Identity maps are thread-local and only persist for the duration of the block,
-    # so they should only be considered as a possible performance enhancer.
-    #
-    # The identity_map plugin is not compatible with the eager loading in the +rcte_tree+ plugin.
-    #
-    # Usage:
-    #
-    #   # Use an identity map that will affect all model classes (called before loading subclasses)
-    #   Sequel::Model.plugin :identity_map
-    #
-    #   # Use an identity map just for the Album class
-    #   Album.plugin :identity_map
-    #   # would need to do Album.with_identity_map{} to use the identity map
-    module IdentityMap
-      def self.apply(mod)
-        Sequel::Deprecation.deprecate('The identity_map plugin', 'Please stop loading it') unless defined?(SEQUEL_EXTENSIONS_NO_DEPRECATION_WARNING)
-      end
-
-      module ClassMethods
-        # Override the default :eager_loader option for many_*_many associations to work
-        # with an identity_map.  If the :eager_graph association option is used, you'll probably have to use
-        # :uniq=>true on the current association and :cartesian_product_number=>2 on the association
-        # mentioned by :eager_graph, otherwise you'll end up with duplicates because the row proc will be
-        # getting called multiple times for the same object.  If you do have duplicates and you use :eager_graph,
-        # they'll probably be lost.  Making that work correctly would require changing a lot of the core
-        # architecture, such as how graphing and eager graphing work.
-        def associate(type, name, opts = {}, &block)
-          if opts[:eager_loader]
-            super
-          elsif type == :many_to_many
-            opts = super
-            el = opts[:eager_loader] 
-            model = self
-            left_pk = opts[:left_primary_key]
-            uses_lcks = opts[:uses_left_composite_keys]
-            uses_rcks = opts[:uses_right_composite_keys]
-            right = opts[:right_key]
-            rcks = opts[:right_keys]
-            join_table = opts[:join_table]
-            left = opts[:left_key]
-            lcks = opts[:left_keys]
-            left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
-            opts[:eager_loader] = lambda do |eo|
-              return el.call(eo) unless model.identity_map
-              h = eo[:id_map]
-              eo[:rows].each{|object| object.associations[name] = []}
-              r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
-              l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, h.keys]] : [[left, h.keys]]
-
-              # Replace the row proc to remove the left key alias before calling the previous row proc.
-              # Associate the value of the left key alias with the associated object (through its object_id).
-              # When loading the associated objects, lookup the left key alias value and associate the
-              # associated objects to the main objects if the left key alias value matches the left primary key
-              # value of the main object.
-              # 
-              # The deleting of the left key alias from the hash before calling the previous row proc
-              # is necessary when an identity map is used, otherwise if the same associated object is returned more than
-              # once for the association, it won't know which of current objects to associate it to.
-              ds = opts.associated_class.inner_join(join_table, r + l)
-              pr = ds.row_proc
-              h2 = {}
-              ds.row_proc = proc do |hash|
-                hash_key = if uses_lcks
-                  left_key_alias.map{|k| hash.delete(k)}
-                else
-                  hash.delete(left_key_alias)
-                end
-                obj = pr.call(hash)
-                (h2[obj.object_id] ||= []) << hash_key
-                obj
-              end
-              model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo) .all do |assoc_record|
-                if hash_keys = h2.delete(assoc_record.object_id)
-                  hash_keys.each do |hash_key|
-                    if objects = h[hash_key]
-                      objects.each{|object| object.associations[name].push(assoc_record)}
-                    end
-                  end
-                end
-              end
-            end
-            opts
-          elsif type == :many_through_many
-            opts = super
-            el = opts[:eager_loader] 
-            model = self
-            left_pk = opts[:left_primary_key]
-            left_key = opts[:left_key]
-            uses_lcks = opts[:uses_left_composite_keys]
-            left_keys = Array(left_key)
-            left_key_alias = opts[:left_key_alias]
-            opts[:eager_loader] = lambda do |eo|
-              return el.call(eo) unless model.identity_map
-              h = eo[:id_map]
-              eo[:rows].each{|object| object.associations[name] = []}
-              ds = opts.associated_class 
-              opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-              ft = opts.final_reverse_edge
-              conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
-
-              # See above comment in many_to_many eager_loader
-              ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
-              pr = ds.row_proc
-              h2 = {}
-              ds.row_proc = proc do |hash|
-                hash_key = if uses_lcks
-                  left_key_alias.map{|k| hash.delete(k)}
-                else
-                  hash.delete(left_key_alias)
-                end
-                obj = pr.call(hash)
-                (h2[obj.object_id] ||= []) << hash_key
-                obj
-              end
-              model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
-                if hash_keys = h2.delete(assoc_record.object_id)
-                  hash_keys.each do |hash_key|
-                    if objects = h[hash_key]
-                      objects.each{|object| object.associations[name].push(assoc_record)}
-                    end
-                  end
-                end
-              end
-            end
-            opts
-          else
-            super
-          end
-        end
-          
-        # Returns the current thread-local identity map.  Should be a hash if
-        # there is an active identity map, and nil otherwise.
-        def identity_map
-          Thread.current[:sequel_identity_map]
-        end
-
-        # The identity map key for an object of the current class with the given pk.
-        # May not always be correct for a class which uses STI.
-        def identity_map_key(pk)
-          pk = Array(pk)
-          "#{self}:#{pk.join(',')}" unless pk.compact.empty?
-        end
-
-        # If the identity map is in use, check it for a current copy of the object.
-        # If a copy does not exist, create a new object and add it to the identity map.
-        # If a copy exists, add any values in the given row that aren't currently
-        # in the object to the object's values.  This allows you to only request
-        # certain fields in an initial query, make modifications to some of those
-        # fields and request other, potentially overlapping fields in a new query,
-        # and not have the second query override fields you modified.
-        def call(row)
-          return super unless (idm = identity_map) && (pk = primary_key)
-          if (k = identity_map_key(Array(pk).map{|x| row[x]})) && (o = idm[k])
-            o.merge_db_update(row)
-          else
-            o = super
-            if (k = identity_map_key(o.pk))
-              idm[k] = o
-            end
-          end
-          o
-        end
-
-        # Take a block and inside that block use an identity map to ensure a 1-1
-        # correspondence of objects to the database row they represent.
-        def with_identity_map
-          return yield if identity_map
-          begin
-            self.identity_map = {}
-            yield
-          ensure
-            self.identity_map = nil
-          end
-        end
-
-        private
-
-        # Set the thread local identity map to the given value.
-        def identity_map=(v)
-          Thread.current[:sequel_identity_map] = v
-        end
-
-        # Check the current identity map if it exists for the object with
-        # the matching pk.  If one is found, return it, otherwise call super.
-        def primary_key_lookup(pk)
-          ((idm = identity_map) && (k = identity_map_key(pk)) && (o = idm[k])) ? o : super
-        end
-      end
-
-      module InstanceMethods
-        # Remove instances from the identity map cache if they are deleted.
-        def delete
-          super
-          if (idm = model.identity_map) && (k = model.identity_map_key(pk))
-            idm.delete(k)
-          end
-          self
-        end
-
-        # Merge the current values into the values provided in the row, ensuring
-        # that current values are not overridden by new values.
-        def merge_db_update(row)
-          @values = row.merge(@values)
-        end
-
-        private
-
-        # The primary keys values of the associated object, given the foreign
-        # key columns(s).
-        def _associated_object_pk(fk)
-          fk.is_a?(Array) ? fk.map{|c| send(c)} : send(fk)
-        end
-
-        # If the association is a many_to_one and it has a :key option and the
-        # key option has a value and the association uses the primary key of
-        # the associated class as the :primary_key option, check the identity
-        # map for the associated object and return it if present.
-        def _load_associated_object(opts, dynamic_opts)
-          klass = opts.associated_class
-          cache_lookup = opts.fetch(:idm_cache_lookup) do 
-            opts[:idm_cache_lookup] = klass.respond_to?(:identity_map) &&
-              opts[:type] == :many_to_one &&
-              opts[:key] &&
-              opts.primary_key == klass.primary_key
-          end
-          if cache_lookup &&
-            !dynamic_opts[:callback] &&
-            (idm = klass.identity_map) &&
-            (k = klass.identity_map_key(_associated_object_pk(opts[:key]))) && 
-            (o = idm[k])
-            o
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sequel_core.rb

@@ -1,2 +0,0 @@
-require 'sequel/core'
-Sequel::Deprecation.deprecate('require "sequel_core"', 'Switch to require "sequel/core"')

data/lib/sequel_model.rb

@@ -1,2 +0,0 @@
-require 'sequel/model'
-Sequel::Deprecation.deprecate('require "sequel_model"', 'Switch to require "sequel"')

data/spec/extensions/association_autoreloading_spec.rb

@@ -1,102 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "AssociationAutoreloading plugin" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.plugin :association_autoreloading
-    @Artist = Class.new(@c).set_dataset(:artists)
-    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
-    @Album = Class.new(@c).set_dataset(:albums)
-    @Artist.columns :id, :name
-    @Album.columns :id, :name, :artist_id
-    @Album.db_schema[:artist_id][:type] = :integer
-    @Album.many_to_one :artist, :class=>@Artist
-    MODEL_DB.reset
-  end
-
-  specify "should reload many_to_one association when foreign key is modified" do
-    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
-    album.artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-
-    album.artist_id = 1
-    album.artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-  end
-
-  specify "should handle multiple many_to_one association with the same foreign key" do
-    @Album.many_to_one :artist2, :key=>:artist_id, :class=>@Artist
-    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
-    album.artist
-    album.artist2
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1'] * 2
-
-    album.artist
-    album.artist2
-    MODEL_DB.sqls.should == []
-
-    album.artist_id = 1
-    album.artist
-    album.artist2
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1'] * 2
-  end
-
-  specify "should not reload when value has not changed" do
-    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
-    album.artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-
-    album.artist_id = 2
-    album.artist
-    MODEL_DB.sqls.should == []
-
-    album.artist_id = "2"
-    album.artist
-    MODEL_DB.sqls.should == []
-  end
-
-  specify "should reload all associations which use the foreign key" do
-    @Album.many_to_one :other_artist, :key => :artist_id, :foreign_key => :id, :class => @Artist
-    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
-    album.artist
-    album.other_artist
-    MODEL_DB.reset
-
-    album.artist_id = 1
-    album.artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-
-    album.other_artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-  end
-
-  specify "should work with composite keys" do
-    @Album.many_to_one :composite_artist, :key => [:artist_id, :name], :primary_key => [:id, :name], :class => @Artist
-    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
-    album.composite_artist
-    MODEL_DB.reset
-
-    album.artist_id = 1
-    album.composite_artist
-    MODEL_DB.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 1) AND (artists.name = 'Al')) LIMIT 1"]
-
-    album.name = 'Al2'
-    album.composite_artist
-    MODEL_DB.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 1) AND (artists.name = 'Al2')) LIMIT 1"]
-  end
-
-  specify "should work with subclasses" do
-    salbum = Class.new(@Album)
-    oartist = Class.new(@c).set_dataset(:oartist)
-    oartist.columns :id, :name
-    salbum.many_to_one :artist2, :class=>oartist, :key=>:artist_id
-    album = salbum.load(:id => 1, :name=>'Al', :artist_id=>2)
-    album.artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-
-    album.artist_id = 1
-    album.artist
-    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-  end
-
-end

data/spec/extensions/identity_map_spec.rb

@@ -1,337 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
-
-describe "Sequel::Plugins::IdentityMap" do
-  before do
-    class ::IdentityMapModel < Sequel::Model
-      plugin :identity_map
-      attr_accessor :foo
-      dataset._fetch = proc do |sql|
-        sql =~ /WHERE \(?(\w+\.)?(\w+) = (\d)\)?/
-        {$2.to_sym=>$3.to_i}
-      end
-      def self.waw_identity_map(&block) # with and without
-        with_identity_map(&block)
-        db.reset
-        yield
-      end
-    end
-    class ::IdentityMapAlbum < ::IdentityMapModel
-      columns :artist_id
-    end
-    class ::IdentityMapArtist < ::IdentityMapModel
-    end
-    @c = ::IdentityMapModel
-    @c1 = ::IdentityMapAlbum
-    @c2 = ::IdentityMapArtist
-    MODEL_DB.reset
-  end
-  after do
-    Object.send(:remove_const, :IdentityMapAlbum)
-    Object.send(:remove_const, :IdentityMapArtist)
-    Object.send(:remove_const, :IdentityMapModel)
-  end
-
-  it "#identity_map should return a hash if an identity map is currently being used" do
-    @c.with_identity_map{@c.identity_map.should == {}}
-  end
-
-  it "#identity_map should return nil if an identity map is not currently being used" do
-    @c.identity_map.should == nil
-  end
-
-  it "#identity_map_key should be the same for the same class and pk" do
-    @c.identity_map_key(1).should == @c.identity_map_key(1)
-  end
-
-  it "#identity_map_key should be different for a different class" do
-    @c1.identity_map_key(1).should_not == @c2.identity_map_key(1)
-  end
-
-  it "#identity_map_key should be different for different anonymous classes" do
-    Class.new(@c).identity_map_key(1).should_not == Class.new(@c).identity_map_key(1)
-  end
-
-  it "#identity_map_key should be different for a different pk" do
-    @c.identity_map_key(1).should_not == @c.identity_map_key(2)
-  end
-
-  it "#identity_map_key should be nil for an empty pk values" do
-    @c.identity_map_key(nil).should == nil
-    @c.identity_map_key([]).should == nil
-    @c.identity_map_key([nil]).should == nil
-  end
-
-  it "#load should work even if model doesn't have a primary key" do
-    c = Class.new(@c)
-    c.no_primary_key
-    proc{c.with_identity_map{c.load({})}}.should_not raise_error
-    c.with_identity_map{c.load({}).should_not equal(c.load({}))}
-  end
-
-  it "#load should return an object if there is no current identity map" do
-    o = @c.load(:id=>1)
-    o.should be_a_kind_of(@c)
-    o.values.should == {:id=>1}
-  end
-
-  it "#load should return an object if there is a current identity map" do
-    @c.with_identity_map do
-      o = @c.load(:id=>1)
-      o.should be_a_kind_of(@c)
-      o.values.should == {:id=>1}
-    end
-  end
-
-  it "#load should store the object in the current identity map if it isn't already there" do
-    @c.with_identity_map do
-      @c.identity_map[@c.identity_map_key(1)].should == nil
-      o = @c.load(:id=>1)
-      @c.identity_map[@c.identity_map_key(1)].should == o
-    end
-  end
-
-  it "#load should update the record in the current identity map if new fields if it is already there" do
-    @c.with_identity_map do
-      o = @c.load(:id=>1, :a=>2)
-      o.values.should == {:id=>1, :a=>2}
-      o = @c.load(:id=>1, :b=>3)
-      o.values.should == {:id=>1, :a=>2, :b=>3}
-    end
-  end
-
-  it "#load should not update existing fields in the record if the record is in the current identity map" do
-    @c.with_identity_map do
-      o = @c.load(:id=>1, :a=>2)
-      o.values.should == {:id=>1, :a=>2}
-      o = @c.load(:id=>1, :a=>4)
-      o.values.should == {:id=>1, :a=>2}
-    end
-  end
-
-  it "should use the identity map as a lookup cache in Model.[] to save on database queries" do
-    @c.with_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      o = @c[1]
-      MODEL_DB.sqls.length.should == 1
-      o.foo = 1
-      @c[1].foo.should == o.foo
-      MODEL_DB.sqls.length.should == 0
-      @c[2].foo.should_not == o.foo
-      MODEL_DB.sqls.length.should == 1
-    end
-  end
-
-  it "should remove instances from the identity map if they are deleted or destroyed" do
-    @c.with_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      o = @c[1]
-      MODEL_DB.sqls.length.should == 1
-      o.foo = 1
-      @c[1].should == o
-      MODEL_DB.sqls.length.should == 0
-      o.destroy
-      MODEL_DB.sqls.length.should == 1
-      @c[1].foo.should_not == o.foo
-      MODEL_DB.sqls.length.should == 1
-
-      MODEL_DB.reset
-      o = @c[2]
-      MODEL_DB.sqls.length.should == 1
-      o.foo = 1
-      @c[2].should == o
-      MODEL_DB.sqls.length.should == 0
-      o.delete
-      MODEL_DB.sqls.length.should == 1
-      @c[2].foo.should_not == o.foo
-      MODEL_DB.sqls.length.should == 1
-    end
-  end
-
-  it "should use the identity map as a lookup cache when retrieving many_to_one associated records via a composite key" do
-    @c1.columns :another_id
-    @c1.many_to_one :artist, :class=>@c2, :key=>[:id, :another_id]
-    @c.with_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      o = @c1.load(:id=>1, :another_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=>1, :another_id=>2, :artist_id=>2)
-      o.artist.should == a
-      MODEL_DB.sqls.length.should == 0
-      o = @c1.load(:id=>3, :another_id=>3, :artist_id=>3)
-      o.artist.should_not == a
-      MODEL_DB.sqls.length.should == 1
-    end
-  end
-
-  it "should use the identity map as a lookup cache when retrieving many_to_one associated records" 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 use the identity map as a lookup cache for a one_to_one association" do
-    @c2.one_to_one :artist, :class=>@c1, :key=>:artist_id
-    @c.with_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      o = @c2.load(:id=>2)
-      a = o.artist
-      a.should be_a_kind_of(@c1)
-      MODEL_DB.sqls.length.should == 1
-      o.reload
-      MODEL_DB.sqls.length.should == 1
-      o.artist.should == a
-      MODEL_DB.sqls.length.should == 1
-    end
-  end
-
-  it "should not use the identity map as a lookup cache if the assocation has a nil :key option" do
-    c = @c2
-    @c1.many_to_one :artist, :class=>@c2, :key=>nil, :dataset=>proc{c.filter(:artist_id=>artist_id)}
-    @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 == 1
-    end
-  end
-
-  it "should not use the identity map as a lookup cache if the assocation's :primary_key option doesn't match the primary key of the associated class" do
-    @c1.many_to_one :artist, :class=>@c2, :primary_key=>:artist_id
-    @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 == 1
-    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
-    c = @c2
-    @c1.many_to_many :artists, :class=>@c2, :left_key=>:album_id, :right_key=>:artist_id, :join_table=>:aa, :eager_loader=>(proc do |eo|
-       eo[:rows].each{|object| object.associations[:artists] = [c.load(:id=>object.id)]}
-    end)
-    @c1.dataset._fetch = [{:id=>1}, {:id=>2}, {:id=>3}]
-
-    @c.waw_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      a = @c1.eager(:artists).all
-      MODEL_DB.sqls.length.should == 1
-      a.should == [@c1.load(:id=>1), @c1.load(:id=>2), @c1.load(:id=>3)]
-      a.map{|x| x.artists}.should == [[@c2.load(:id=>1)], [@c2.load(:id=>2)], [@c2.load(:id=>3)]]
-      MODEL_DB.sqls.length.should == 0
-    end
-  end
-
-  it "should work correctly when eagerly loading many_to_many associations" do
-    @c1.columns :id
-    @c2.columns :id
-    @c1.many_to_many :artists, :class=>@c2, :left_key=>:album_id, :right_key=>:artist_id, :join_table=>:aa
-    @c1.dataset._fetch = [{:id=>1}, {:id=>2}, {:id=>3}]
-    @c2.dataset._fetch = [{:id=>1, :x_foreign_key_x=>1}, {:id=>1, :x_foreign_key_x=>2}, {:id=>2, :x_foreign_key_x=>1}, {:id=>2, :x_foreign_key_x=>2}, {:id=>3, :x_foreign_key_x=>1}, {:id=>3, :x_foreign_key_x=>1}]
-
-    @c.waw_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      a = @c1.eager(:artists).all
-      MODEL_DB.sqls.length.should == 2
-      a.should == [@c1.load(:id=>1), @c1.load(:id=>2), @c1.load(:id=>3)]
-      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
-      MODEL_DB.sqls.length.should == 0
-    end
-  end
-
-  it "should work correctly when eagerly loading many_to_many associations with composite keys" do
-    @c1.columns :id, :id2
-    @c2.columns :id, :id2
-    @c1.set_primary_key [:id, :id2]
-    @c2.set_primary_key [:id, :id2]
-    @c1.many_to_many :artists, :class=>@c2, :left_key=>[:album_id1, :album_id2], :right_key=>[:artist_id1, :artist_id2], :join_table=>:aa
-    @c1.dataset._fetch = [{:id=>1, :id2=>4}, {:id=>2, :id2=>5}, {:id=>3, :id2=>6}]
-    @c2.dataset._fetch = [ {:id=>1, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>1, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>2, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>2, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}]
-
-    @c.waw_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      a = @c1.eager(:artists).all
-      MODEL_DB.sqls.length.should == 2
-      a.should == [@c1.load(:id=>1, :id2=>4), @c1.load(:id=>2, :id2=>5), @c1.load(:id=>3, :id2=>6)]
-      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
-      MODEL_DB.sqls.length.should == 0
-    end
-  end
-
-  it "should work correctly when eagerly loading many_through_many associations" do
-    @c1.columns :id
-    @c2.columns :id
-    @c1.plugin :many_through_many
-    @c1.many_through_many :artists, [[:aa, :album_id, :artist_id]], :class=>@c2
-    @c1.dataset._fetch = [{:id=>1}, {:id=>2}, {:id=>3}]
-    @c2.dataset._fetch = [{:id=>1, :x_foreign_key_x=>1}, {:id=>1, :x_foreign_key_x=>2}, {:id=>2, :x_foreign_key_x=>1}, {:id=>2, :x_foreign_key_x=>2}, {:id=>3, :x_foreign_key_x=>1}, {:id=>3, :x_foreign_key_x=>1}]
-
-    @c.waw_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      a = @c1.eager(:artists).all
-      MODEL_DB.sqls.length.should == 2
-      a.should == [@c1.load(:id=>1), @c1.load(:id=>2), @c1.load(:id=>3)]
-      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
-      MODEL_DB.sqls.length.should == 0
-    end
-  end
-
-  it "should work correctly when eagerly loading many_to_many associations with composite keys" do
-    @c1.columns :id, :id2
-    @c2.columns :id
-    @c1.set_primary_key [:id, :id2]
-    @c1.plugin :many_through_many
-    @c1.many_through_many :artists, [[:aa, [:album_id1, :album_id2], :artist_id]], :class=>@c2
-    @c1.dataset._fetch = [{:id=>1, :id2=>4}, {:id=>2, :id2=>5}, {:id=>3, :id2=>6}]
-    @c2.dataset._fetch = [ {:id=>1, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>1, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>2, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>2, :x_foreign_key_0_x=>2, :x_foreign_key_1_x=>5}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}, {:id=>3, :x_foreign_key_0_x=>1, :x_foreign_key_1_x=>4}]
-
-    @c.waw_identity_map do
-      MODEL_DB.sqls.length.should == 0
-      a = @c1.eager(:artists).all
-      MODEL_DB.sqls.length.should == 2
-      a.should == [@c1.load(:id=>1, :id2=>4), @c1.load(:id=>2, :id2=>5), @c1.load(:id=>3, :id2=>6)]
-      a.map{|x| x.artists}.should == [[@c2.load(:id=>1), @c2.load(:id=>2), @c2.load(:id=>3), @c2.load(:id=>3)], [@c2.load(:id=>1), @c2.load(:id=>2)], []]
-      MODEL_DB.sqls.length.should == 0
-    end
-  end
-end