sequel 3.21.0 → 3.39.0

data/lib/sequel/plugins/dataset_associations.rb

@@ -0,0 +1,100 @@
+module Sequel
+  module Plugins
+    # DatasetAssociations allows you to easily use your model associations
+    # via datasets.  For each association you define, it creates a dataset
+    # method for that association that returns a dataset of all objects
+    # that are associated to objects in the current dataset.  Here's a simple
+    # example:
+    #
+    #   class Artist < Sequel::Model
+    #     plugin :dataset_associations
+    #     one_to_many :albums
+    #   end
+    #   Artist.filter(id=>1..100).albums
+    #   # SELECT * FROM albums
+    #   # WHERE (albums.artist_id IN (
+    #   #   SELECT id FROM artists
+    #   #   WHERE ((id >= 1) AND (id <= 100))))
+    # 
+    # This works for all of the association types that ship with Sequel,
+    # including the many_through_many type.  Most association options that
+    # are supported when eager loading are supported when using a
+    # dataset association.  However, associations that use :limit or
+    # one_to_one associations that are really one_to_many relationships
+    # in the database will not work correctly, returning all associated
+    # objects.
+    #
+    # As the dataset methods return datasets, you can easily chain the
+    # methods to get associated datasets of associated datasets:
+    #
+    #   Artist.filter(id=>1..100).albums.filter{name < 'M'}.tags
+    #   # SELECT tags.* FROM tags
+    #   # WHERE (tags.id IN (
+    #   #   SELECT albums_tags.tag_id FROM albums
+    #   #   INNER JOIN albums_tags
+    #   #     ON (albums_tags.album_id = albums.id)
+    #   #   WHERE
+    #   #     ((albums.artist_id IN (
+    #   #       SELECT id FROM artists
+    #   #       WHERE ((id >= 1) AND (id <= 100)))
+    #   #     AND
+    #   #     (name < 'M')))))
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses create association methods for datasets
+    #   Sequel::Model.plugin :dataset_associations
+    #
+    #   # Make the Album class create association methods for datasets
+    #   Album.plugin :dataset_associations
+    module DatasetAssociations
+      module ClassMethods
+        # Set up a dataset method for each association to return an associated dataset
+        def associate(type, name, *)
+          ret = super
+          r = association_reflection(name)
+          meth = r.returns_array? ? name : pluralize(name).to_sym
+          def_dataset_method(meth){associated(name)}
+          ret
+        end
+      end
+
+      module DatasetMethods
+        # For the association given by +name+, return a dataset of associated objects
+        # such that it would return the union of calling the association method on
+        # all objects returned by the current dataset.
+        #
+        # This supports most options that are supported when eager loading.  It doesn't
+        # support limits on the associations, or one_to_one associations that are really
+        # one_to_many and use an order to select the first matching object.  In both of
+        # those cases, this will return an array of all matching objects.
+        def associated(name)
+          raise Error, "unrecognized association name: #{name.inspect}" unless r = model.association_reflection(name)
+          ds = r.associated_class.dataset
+          sds = opts[:limit] ? self : unordered
+          ds = case r[:type]
+          when :many_to_one
+            ds.filter(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
+          when :one_to_one, :one_to_many
+            ds.filter(r.qualified_key=>sds.select(*Array(r.qualified_primary_key)))
+          when :many_to_many
+            ds.filter(r.qualified_right_primary_key=>sds.select(*Array(r.qualified_right_key)).
+              join(r[:join_table], r[:left_keys].zip(r[:left_primary_keys]), :implicit_qualifier=>model.table_name))
+          when :many_through_many
+            fre = r.reverse_edges.first
+            fe, *edges = r.edges
+            sds = sds.select(*Array(r.qualify(fre[:table], fre[:left]))).
+              join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name)
+            edges.each{|e| sds = sds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
+            ds.filter(r.qualified_right_primary_key=>sds)
+          else
+            raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
+          end
+          ds = model.apply_association_dataset_opts(r, ds)
+          r[:extend].each{|m| ds.extend(m)}
+          ds
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/defaults_setter.rb

@@ -0,0 +1,72 @@
+module Sequel
+  module Plugins
+    # DefaultsSetter is a simple plugin that sets non-nil/NULL default values upon
+    # initialize:
+    #
+    #   # column a default NULL
+    #   # column b default 2
+    #   album = Album.new.values # {:b => 2}
+    #   album = Album.new(:a=>1, :b=>3).values # {:a => 1, :b => 3}
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances set defaults (called before loading subclasses)
+    #   Sequel::Model.plugin :defaults_setter
+    #
+    #   # Make the Album class set defaults 
+    #   Album.plugin :defaults_setter
+    module DefaultsSetter
+      # Set the default values based on the model schema
+      def self.configure(model)
+        model.send(:set_default_values)
+      end
+
+      module ClassMethods
+        # The default values to set in initialize for this model.  A hash with column symbol
+        # keys and default values.  If the default values respond to +call+, it will be called
+        # to get the value, otherwise the value will be used directly.  You can manually modify
+        # this hash to set specific default values, by default the ones will be parsed from the database.
+        attr_reader :default_values
+        
+        # Set the default values when loading the dataset.
+        def set_dataset(*)
+          x = super
+          set_default_values
+          x
+        end
+
+        private
+
+        # Parse the cached database schema for this model and set the default values appropriately.
+        def set_default_values
+          h = {}
+          @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
+          @default_values = h
+        end
+
+        # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or
+        # Time/DateTime value.
+        def convert_default_value(v)
+          case v
+          when Sequel::CURRENT_DATE
+            lambda{Date.today}
+          when Sequel::CURRENT_TIMESTAMP
+            lambda{Sequel.datetime_class.now}
+          else
+            v
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Set default values if they are not already set by the hash provided to initialize.
+        def initialize_set(h)
+          super
+          model.default_values.each{|k,v| self[k] = (v.respond_to?(:call) ? v.call : v) unless values.has_key?(k)}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/dirty.rb

@@ -0,0 +1,214 @@
+module Sequel
+  module Plugins
+    # The dirty plugin makes Sequel save the initial value of
+    # a column when setting a new value for the column.  This
+    # makes it easier to see what changes were made to the object:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.initial_value(:name)   # 'Foo'
+    #   artist.column_change(:name)   # ['Foo', 'Bar']
+    #   artist.column_changes         # {:name => ['Foo', 'Bar']}
+    #   artist.column_changed?(:name) # true
+    #   artist.reset_column(:name)
+    #   artist.name                   # => 'Foo'
+    #   artist.column_changed?(:name) # false
+    #
+    # It also makes changed_columns more accurate in that it
+    # can detect when a the column value is changed and then
+    # changed back:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.changed_columns        # => [:name]
+    #   artist.name = 'Foo'
+    #   artist.changed_columns        # => []
+    #
+    # It can handle situations where a column value is
+    # modified in place:
+    #
+    #   artist.will_change_column(:name)
+    #   artist.name.gsub!(/o/, 'u')
+    #   artist.changed_columns       # => [:name]
+    #   artist.initial_value(:name)  # => 'Foo'
+    #   artist.column_change(:name)  # => ['Foo', 'Fuu']
+    #
+    # It also saves the previously changed values after an update:
+    #
+    #   artist.update(:name=>'Bar')
+    #   artist.column_changes        # => {}
+    #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances record previous values (called before loading subclasses)
+    #   Sequel::Model.plugin :dirty
+    #
+    #   # Make the Album class record previous values
+    #   Album.plugin :dirty
+    module Dirty
+      module InstanceMethods
+        # A hash of previous changes before the object was
+        # saved, in the same format as #column_changes.
+        # Note that this is not necessarily the same as the columns
+        # that were used in the update statement.
+        attr_reader :previous_changes
+
+        # An array with the initial value and the current value
+        # of the column, if the column has been changed.  If the
+        # column has not been changed, returns nil.
+        #
+        #   column_change(:name) # => ['Initial', 'Current']
+        def column_change(column)
+          [initial_value(column), send(column)] if column_changed?(column)
+        end
+
+        # A hash with column symbol keys and pairs of initial and
+        # current values for all changed columns.
+        #
+        #   column_changes # => {:name => ['Initial', 'Current']}
+        def column_changes
+          h = {}
+          initial_values.each do |column, value|
+            h[column] = [value, send(column)]
+          end
+          h
+        end
+
+        # Either true or false depending on whether the column has
+        # changed.  Note that this is not exactly the same as checking if
+        # the column is in changed_columns, if the column was not set
+        # initially.
+        #
+        #   column_changed?(:name) # => true
+        def column_changed?(column)
+          initial_values.has_key?(column)
+        end
+
+        # The initial value of the given column.  If the column value has
+        # not changed, this will be the same as the current value of the
+        # column.
+        #
+        #   initial_value(:name) # => 'Initial'
+        def initial_value(column)
+          initial_values.fetch(column){send(column)}
+        end
+
+        # A hash with column symbol keys and initial values.
+        #
+        #   initial_values # {:name => 'Initial'}
+        def initial_values
+          @initial_values ||= {}
+        end
+
+        # Reset the column to its initial value.  If the column was not set
+        # initial, removes it from the values.
+        #
+        #   reset_column(:name)
+        #   name # => 'Initial'
+        def reset_column(column)
+          if initial_values.has_key?(column)
+            send(:"#{column}=", initial_values[column])
+          end
+          if missing_initial_values.include?(column)
+            values.delete(column)
+          end
+        end
+
+        # Manually specify that a column will change.  This should only be used
+        # if you plan to modify a column value in place, which is not recommended.
+        #
+        #   will_change_column(:name)
+        #   name.gsub(/i/i, 'o')
+        #   column_change(:name) # => ['Initial', 'onotoal']
+        def will_change_column(column)
+          changed_columns << column unless changed_columns.include?(column)
+          check_missing_initial_value(column)
+
+          value = if initial_values.has_key?(column)
+            initial_values[column]
+          else
+            send(column)
+          end
+
+          initial_values[column] = if value && value != true && value.respond_to?(:clone)
+            begin
+              value.clone
+            rescue TypeError
+              value
+            end
+          else
+            value
+          end
+        end
+
+        private
+
+        # Reset the initial values after saving.
+        def after_save
+          super
+          reset_initial_values
+        end
+
+        # Save the current changes so they are available after updating.  This happens
+        # before after_save resets them.
+        def after_update
+          super
+          @previous_changes = column_changes
+        end
+
+        # Reset the initial values when refreshing.
+        def _refresh(dataset)
+          super
+          reset_initial_values
+        end
+
+        # When changing the column value, save the initial column value.  If the column
+        # value is changed back to the initial value, update changed columns to remove
+        # the column.
+        def change_column_value(column, value)
+          if (iv = initial_values).has_key?(column)
+            initial = iv[column]
+            super
+            if value == initial
+              changed_columns.delete(column) unless missing_initial_values.include?(column)
+              iv.delete(column)
+            end
+          else
+            check_missing_initial_value(column)
+            iv[column] = send(column)
+            super
+          end
+        end
+
+        # If the values hash does not contain the column, make sure missing_initial_values
+        # does so that it doesn't get deleted from changed_columns if changed back,
+        # and so that resetting the column value can be handled correctly.
+        def check_missing_initial_value(column)
+          unless values.has_key?(column) || (miv = missing_initial_values).include?(column)
+            miv << column
+          end
+        end
+
+        # Reset the initial values when initializing.
+        def initialize_set(h)
+          super
+          reset_initial_values
+        end
+
+        # Array holding column symbols that were not present initially.  This is necessary
+        # to differentiate between values that were not present and values that were
+        # present but equal to nil.
+        def missing_initial_values
+          @missing_initial_values ||= []
+        end
+
+        # Clear the data structures that store the initial values.
+        def reset_initial_values
+          @initial_values.clear if @initial_values
+          @missing_initial_values.clear if @missing_initial_values
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/eager_each.rb

@@ -0,0 +1,59 @@
+module Sequel
+  module Plugins
+    # The eager_each plugin makes calling each on an eager loaded dataset do eager loading.
+    # By default, each does not work on an eager loaded dataset, because each iterates
+    # over rows of the dataset as they come in, and to eagerly load you need to have all
+    # values up front.  With the default associations code, you must call #all on an eagerly
+    # loaded dataset, as calling #each on an #eager dataset skips the eager loading, and calling
+    # #each on an #eager_graph dataset makes it yield plain hashes with columns from all
+    # tables, instead of yielding the instances of the main model.
+    #
+    # This plugin makes #each call #all for eagerly loaded datasets.  As #all usually calls
+    # #each, this is a bit of issue, but this plugin resolves the issue by cloning the dataset
+    # and setting a new flag in the cloned dataset, so that each can check with the flag to
+    # determine whether it should call all.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances eagerly load for each (called before loading subclasses)
+    #   Sequel::Model.plugin :eager_each
+    #
+    #   # Make the Album class eagerly load for each
+    #   Album.plugin :eager_each
+    module EagerEach 
+      # Methods added to eagerly loaded datasets when the eager_each plugin is in use.
+      module EagerDatasetMethods
+        # Call #all instead of #each unless #each is being called by #all.
+        def each(&block)
+          if opts[:all_called]
+            super
+          else
+            all(&block)
+          end
+        end
+
+        # Clone the dataset and set a flag to let #each know not to call #all,
+        # to avoid the infinite loop.
+        def all(&block)
+          if opts[:all_called]
+            super
+          else
+            clone(:all_called=>true).all(&block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Make sure calling each on this dataset will eagerly load the dataset.
+        def eager(*)
+          super.extend(EagerDatasetMethods)
+        end
+        
+        # Make sure calling each on this dataset will eagerly load the dataset.
+        def eager_graph(*)
+          super.extend(EagerDatasetMethods)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/force_encoding.rb

@@ -8,7 +8,7 @@ module Sequel
     # attribute, the resulting value is forced to a given encoding if the
     # value is a string.  There are two ways to specify the encoding.  You
     # can either do so in the plugin call itself, or via the
-    # forced_encoding class accessor:
+    # forced_encoding class accessor.
     #
     # Usage:
     #
@@ -46,6 +46,11 @@ module Sequel
           super(force_hash_encoding(row))
         end
         
+        # Force the encoding of all string values when setting the instance's values.
+        def set_values(row)
+          super(force_hash_encoding(row))
+        end
+        
         private
         
         # Force the encoding for all string values in the given row hash.
@@ -55,11 +60,6 @@ module Sequel
           row
         end
         
-        # Force the encoding of all string values when setting the instance's values.
-        def set_values(row)
-          super(force_hash_encoding(row))
-        end
-        
         # Force the encoding of all returned strings to the model's forced_encoding.
         def typecast_value(column, value)
           s = super

data/lib/sequel/plugins/hook_class_methods.rb

@@ -90,9 +90,9 @@ module Sequel
 
         # Make a copy of the current class's hooks for the subclass.
         def inherited(subclass)
-          super
           hooks = subclass.instance_variable_set(:@hooks, {}) 
           instance_variable_get(:@hooks).each{|k,v| hooks[k] = v.dup}
+          super
         end
     
         private

data/lib/sequel/plugins/identity_map.rb

@@ -22,10 +22,7 @@ module Sequel
     # 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 standard eager loading of
-    # many_to_many and many_through_many associations.  If you want to use the identity_map plugin,
-    # you should use +eager_graph+ instead of +eager+ for those associations. It is also
-    # not compatible with the eager loading in the +rcte_tree+ plugin.
+    # The identity_map plugin is not compatible with the eager loading in the +rcte_tree+ plugin.
     #
     # Usage:
     #
@@ -37,6 +34,116 @@ module Sequel
     #   # would need to do Album.with_identity_map{} to use the identity map
     module IdentityMap
       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 amd :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]
+            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
@@ -46,7 +153,8 @@ module Sequel
         # 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)
-          "#{self}:#{pk ? Array(pk).join(',') : "nil:#{rand}"}"
+          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.
@@ -56,13 +164,15 @@ module Sequel
         # 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 load(row)
-          return super unless idm = identity_map
-          if o = idm[identity_map_key(Array(primary_key).map{|x| row[x]})]
+        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
-            idm[identity_map_key(o.pk)] = o
+            if (k = identity_map_key(o.pk))
+              idm[k] = o
+            end
           end
           o
         end
@@ -89,7 +199,7 @@ module Sequel
         # 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 and o = idm[identity_map_key(pk)]) ? o : super
+          ((idm = identity_map) && (k = identity_map_key(pk)) && (o = idm[k])) ? o : super
         end
       end
 
@@ -97,8 +207,8 @@ module Sequel
         # Remove instances from the identity map cache if they are deleted.
         def delete
           super
-          if idm = model.identity_map
-            idm.delete(model.identity_map_key(pk))
+          if (idm = model.identity_map) && (k = model.identity_map_key(pk))
+            idm.delete(k)
           end
           self
         end
@@ -121,10 +231,19 @@ module Sequel
         # 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_objects(opts)
+        def _load_associated_object(opts, dynamic_opts)
           klass = opts.associated_class
-          if klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts[:primary_key] == klass.primary_key and
-           opts[:key] and pk = _associated_object_pk(opts[:key]) and o = idm[klass.identity_map_key(pk)]
+          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