sequel 3.21.0 → 3.32.0

data/lib/sequel/model/errors.rb

@@ -40,7 +40,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}"}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(ATTRIBUTE_JOINER)} #{e}")}
           m
         end
       end

data/lib/sequel/model/exceptions.rb

@@ -1,6 +1,10 @@
 module Sequel
   # Exception class raised when +raise_on_save_failure+ is set and a before hook returns false
-  class BeforeHookFailed < Error; end
+  # or an around hook doesn't call super or yield.
+  class HookFailed < Error; end
+
+  # Deprecated alias for HookFailed, kept for backwards compatibility
+  BeforeHookFailed = HookFailed
   
   # Exception class raised when +require_modification+ is set and an UPDATE or DELETE statement to modify the dataset doesn't
   # modify a single row.

data/lib/sequel/model.rb

@@ -11,9 +11,9 @@ module Sequel
   #             with the +Database+ in +source+ to create the
   #             dataset to use) 
   # Dataset :: Sets the dataset for this model to +source+. 
-  # Symbol :: Sets the table name for this model to +source+. The
-  #           class will use the default database for model
-  #           classes in order to create the dataset.
+  # other :: Sets the table name for this model to +source+. The
+  #          class will use the default database for model
+  #          classes in order to create the dataset.
   #
   # The purpose of this method is to set the dataset/database automatically
   # for a model class, if the table name doesn't match the implicit
@@ -49,10 +49,11 @@ module Sequel
   # called directly on the class.  Model datasets return rows as model instances,
   # which have fairly standard ORM instance behavior.
   #
-  # <tt>Sequel::Model</tt> is built completely out of plugins, the only method not part of a
-  # plugin is the plugin method itself.  Plugins can override any class, instance, or
-  # dataset method defined by a previous plugin and call super to get the default
-  # behavior.
+  # <tt>Sequel::Model</tt> is built completely out of plugins.  Plugins can override any class,
+  # instance, or dataset method defined by a previous plugin and call super to get the default
+  # behavior.  By default, <tt>Sequel::Model</tt> loads two plugins, <tt>Sequel::Model</tt>
+  # (which is itself a plugin) for the base support, and <tt>Sequel::Model::Associations</tt>
+  # for the associations support.
   #
   # You can set the +SEQUEL_NO_ASSOCIATIONS+ constant or environment variable to
   # make Sequel not load the associations plugin by default.
@@ -69,7 +70,8 @@ module Sequel
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]
 
     # Boolean settings that can be modified at the global, class, or instance level.
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions]
+    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
+      :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_after_commit_rollback, :use_transactions]
 
     # Hooks that are called before an action.  Can return false to not do the action.  When
     # overriding these, it is recommended to call +super+ as the last line of your method,
@@ -78,7 +80,13 @@ module Sequel
 
     # Hooks that are called after an action.  When overriding these, it is recommended to call
     # +super+ on the first line of your method, so later hooks are called after earlier hooks.
-    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy, :after_validation]
+    AFTER_HOOKS = [:after_initialize, :after_create, :after_update, :after_save, :after_destroy,
+      :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
+
+    # Hooks that are called around an action.  If overridden, these methods must call super
+    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
+    # raised by the code they wrap or ensure that some behavior is executed no matter what.
+    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
 
     # Empty instance methods to create that the user can override to get hook/callback behavior.
     # Just like any other method defined by Sequel, if you override one of these, you should
@@ -96,7 +104,8 @@ module Sequel
       :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
       :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
-      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil}
+      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
+      :@use_after_commit_rollback=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to
@@ -126,6 +135,7 @@ module Sequel
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
+    @use_after_commit_rollback = true
     @use_transactions = true
 
     Sequel.require %w"default_inflections inflections plugins base exceptions errors", "model"

data/lib/sequel/plugins/active_model.rb

@@ -16,7 +16,14 @@ module Sequel
     #   # Make the Album class active_model compliant
     #   Album.plugin :active_model
     module ActiveModel
-      ClassMethods = ::ActiveModel::Naming
+      module ClassMethods
+        include ::ActiveModel::Naming
+        
+        # Class level cache for to_partial_path.
+        def _to_partial_path
+          @_to_partial_path ||= "#{underscore(pluralize(to_s))}/#{underscore(demodulize(to_s))}".freeze
+        end
+      end
 
       module InstanceMethods
         # The default string to join composite primary keys with in to_param.
@@ -56,6 +63,11 @@ module Sequel
             k.join(to_param_joiner)
           end
         end
+
+        # Returns a string identifying the path associated with the object.
+        def to_partial_path
+          model._to_partial_path
+        end
         
         private
         

data/lib/sequel/plugins/association_pks.rb

@@ -14,7 +14,7 @@ module Sequel
     #
     # Note that it uses the singular form of the association name. Also note
     # that the setter both associates to new primary keys not in the assocation
-    # and disassociated from primary keys not provided to the method.
+    # and disassociates from primary keys not provided to the method.
     #
     # This plugin makes modifications directly to the underlying tables,
     # it does not create or return any model objects, and therefore does
@@ -56,6 +56,7 @@ module Sequel
             _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key])).select_map(opts[:right_key])
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = _join_table_dataset(opts).filter(opts[:left_key]=>send(opts[:left_primary_key]))
               ds.exclude(opts[:right_key]=>pks).delete
@@ -71,17 +72,34 @@ module Sequel
           super
           return if opts[:type] == :one_to_one
           def_association_pks_getter(opts) do
-            send(opts.dataset_method).select_map(opts[:primary_key])
+            send(opts.dataset_method).select_map(opts.associated_class.primary_key)
           end
           def_association_pks_setter(opts) do |pks|
+            pks = convert_pk_array(opts, pks)
             checked_transaction do
               ds = send(opts.dataset_method)
-              ds.unfiltered.filter(opts[:primary_key]=>pks).update(opts[:key]=>pk)
-              ds.exclude(opts[:primary_key]=>pks).update(opts[:key]=>nil)
+              primary_key = opts.associated_class.primary_key
+              key = opts[:key]
+              ds.unfiltered.filter(primary_key=>pks).update(key=>pk)
+              ds.exclude(primary_key=>pks).update(key=>nil)
             end
           end
         end
       end
+
+      module InstanceMethods
+        private
+
+        # If the associated class's primary key column type is integer,
+        # typecast all provided values to integer before using them.
+        def convert_pk_array(opts, pks)
+          if klass = opts.associated_class and sch = klass.db_schema and col = sch[klass.primary_key] and col[:type] == :integer
+            pks.map{|pk| model.db.typecast_value(:integer, pk)}
+          else
+            pks
+          end
+        end
+      end
     end
   end
 end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -90,9 +90,9 @@ module Sequel
           @cti_columns = {table_name=>columns}
           @cti_table_map = opts[:table_map] || {}
           dataset.row_proc = if key
-            lambda{|r| (m.call(r[key]) rescue model).load(r)}
+            lambda{|r| (m.call(r[key]) rescue model).call(r)}
           else
-            lambda{|r| model.load(r)}
+            model
           end
         end
       end
@@ -152,9 +152,9 @@ module Sequel
           subclass.instance_eval do
             m = method(:constantize)
             dataset.row_proc = if cti_key
-              lambda{|r| (m.call(r[ck]) rescue subclass).load(r)}
+              lambda{|r| (m.call(r[ck]) rescue subclass).call(r)}
             else
-              lambda{|r| subclass.load(r)}
+              subclass
             end
             (columns - [cbm.primary_key]).each{|a| define_lazy_attribute_getter(a)}
             cti_tables.reverse.each do |table|

data/lib/sequel/plugins/composition.rb

@@ -1,20 +1,53 @@
 module Sequel
   module Plugins
-    # The composition plugin allows you to easily define getter and
-    # setter instance methods for a class where the backing data
-    # is composed of other getters and decomposed to other setters.
+    # The composition plugin allows you to easily define a virtual
+    # attribute where the backing data is composed of other columns.
     #
-    # A simple example of this is when you have a database table with
-    # separate columns for year, month, and day, but where you want
-    # to deal with Date objects in your ruby code.  This can be handled
-    # with:
+    # There are two ways to use the plugin.  One way is with the
+    # :mapping option.  A simple example of this is when you have a
+    # database table with separate columns for year, month, and day,
+    # but where you want to deal with Date objects in your ruby code.
+    # This can be handled with:
     #
     #   Album.plugin :composition
     #   Album.composition :date, :mapping=>[:year, :month, :day]
     #
-    # The :mapping option is optional, but you can define custom
-    # composition and decomposition procs via the :composer and
-    # :decomposer options.
+    # With the :mapping option, you can provide a :class option
+    # that gives the class to use, but if that is not provided, it
+    # is inferred from the name of the composition (e.g. :date -> Date).
+    # When the <tt>date</tt> method is called, it will return a
+    # Date object by calling:
+    #
+    #   Date.new(year, month, day)
+    #
+    # When saving the object, if the date composition has been used
+    # (by calling either the getter or setter method), it will
+    # populate the related columns of the object before saving:
+    #
+    #   self.year = date.year
+    #   self.month = date.month
+    #   self.day = date.day
+    #
+    # The :mapping option is just a shortcut that works in particular
+    # cases.  To handle any case, you can define a custom :composer
+    # and :decomposer procs.  The :composer proc will be instance_evaled
+    # the first time the getter is called, and the :decomposer proc
+    # will be instance_evaled before saving.  The above example could
+    # also be implemented as:
+    #
+    #   Album.composition, :date,
+    #     :composer=>proc{Date.new(year, month, day) if year || month || day},
+    #     :decomposer=>(proc do
+    #       if d = compositions[:date]
+    #         self.year = d.year
+    #         self.month = d.month
+    #         self.day = d.day
+    #       else
+    #         self.year = nil
+    #         self.month = nil
+    #         self.day = nil
+    #       end
+    #     end)
     #
     # Note that when using the composition object, you should not
     # modify the underlying columns if you are also instantiating

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,58 @@
+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
+
+        def set_default_values
+          h = {}
+          @db_schema.each{|k, v| h[k] = v[:ruby_default] if v[:ruby_default]} if @db_schema
+          @default_values = h
+        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/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/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[:key_hash][left_pk]
+              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[:key_hash][left_pk]
+              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
@@ -56,7 +163,7 @@ 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)
+        def call(row)
           return super unless idm = identity_map
           if o = idm[identity_map_key(Array(primary_key).map{|x| row[x]})]
             o.merge_db_update(row)
@@ -121,9 +228,9 @@ 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_objects(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
+          if !dynamic_opts[:callback] && 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)]
             o
           else