sequel 4.36.0 → 5.61.0

data/lib/sequel/model/associations.rb

@@ -7,46 +7,54 @@ module Sequel
     module Associations
       # Map of association type symbols to association reflection classes.
       ASSOCIATION_TYPES = {}
-    
+
       # Set an empty association reflection hash in the model
       def self.apply(model)
-        model.instance_eval do
+        model.instance_exec do
           @association_reflections = {}
           @autoreloading_associations = {}
           @cache_associations = true
+          @default_eager_limit_strategy = true
           @default_association_options = {}
+          @default_association_type_options = {}
+          @dataset_module_class = DatasetModule
         end
       end
 
+      # The dataset module to use for classes using the associations plugin.
+      class DatasetModule < Model::DatasetModule
+        def_dataset_caching_method(self, :eager)
+      end
+
       # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
       # provides methods to reduce internal code duplication.  It should not
       # be instantiated by the user.
       class AssociationReflection < Hash
         include Sequel::Inflections
-    
+
         # Name symbol for the _add internal association method
         def _add_method
-          :"_add_#{singularize(self[:name])}"
+          self[:_add_method]
         end
       
         # Name symbol for the _remove_all internal association method
         def _remove_all_method
-          :"_remove_all_#{self[:name]}"
+          self[:_remove_all_method]
         end
       
         # Name symbol for the _remove internal association method
         def _remove_method
-          :"_remove_#{singularize(self[:name])}"
+          self[:_remove_method]
         end
       
         # Name symbol for the _setter association method
         def _setter_method
-          :"_#{self[:name]}="
+          self[:_setter_method]
         end
       
         # Name symbol for the add association method
         def add_method
-          :"add_#{singularize(self[:name])}"
+          self[:add_method]
         end
       
         # Name symbol for association method, the same as the name of the association.
@@ -56,7 +64,13 @@ module Sequel
       
         # The class associated to the current model class via this association
         def associated_class
-          cached_fetch(:class){constantize(self[:class_name])}
+          cached_fetch(:class) do
+            begin
+              constantize(self[:class_name])
+            rescue NameError => e
+              raise NameError, "#{e.message} (this happened when attempting to find the associated class for #{inspect})", e.backtrace
+            end
+          end
         end
 
         # The dataset associated via this association, with the non-instance specific
@@ -68,16 +82,17 @@ module Sequel
 
         # Apply all non-instance specific changes to the given dataset and return it.
         def apply_dataset_changes(ds)
-          ds.extend(AssociationDatasetMethods)
-          ds.association_reflection = self
-          self[:extend].each{|m| ds.extend(m)}
+          ds = ds.with_extend(AssociationDatasetMethods).clone(:association_reflection => self)
+          if exts = self[:reverse_extend]
+            ds = ds.with_extend(*exts)
+          end
           ds = ds.select(*select) if select
           if c = self[:conditions]
             ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
           end
           ds = ds.order(*self[:order]) if self[:order]
           ds = ds.limit(*self[:limit]) if self[:limit]
-          ds = ds.limit(1) if limit_to_single_row?
+          ds = ds.limit(1).skip_limit_check if limit_to_single_row?
           ds = ds.eager(self[:eager]) if self[:eager]
           ds = ds.distinct if self[:distinct]
           ds
@@ -129,7 +144,8 @@ module Sequel
         def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset())
           rn = ds.row_number_column 
           limit, offset = limit_and_offset
-          ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
+          ds = ds.unordered.select_append{|o| o.row_number.function.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
+          ds = ds.order(rn) if ds.db.database_type == :mysql
           ds = if !returns_array?
             ds.where(rn => offset ? offset+1 : 1)
           elsif offset
@@ -148,11 +164,11 @@ module Sequel
         # range to return the object(s) at the correct offset/limit.
         def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
           name = self[:name]
+          return unless range = slice_range(limit_and_offset)
           if returns_array?
-            range = slice_range(limit_and_offset)
             rows.each{|o| o.associations[name] = o.associations[name][range] || []}
-          elsif sr = slice_range(limit_and_offset)
-            offset = sr.begin
+          else
+            offset = range.begin
             rows.each{|o| o.associations[name] = o.associations[name][offset]}
           end
         end
@@ -178,7 +194,7 @@ module Sequel
 
         # Name symbol for the dataset association method
         def dataset_method
-          :"#{self[:name]}_dataset"
+          self[:dataset_method]
         end
       
         # Whether the dataset needs a primary key to function, true by default.
@@ -197,7 +213,13 @@ module Sequel
         # Return an dataset that will load the appropriate associated objects for
         # the given object using this association.
         def association_dataset_for(object)
-          associated_dataset.where(predicate_keys.zip(predicate_key_values(object)))
+          condition = if can_have_associated_objects?(object)
+            predicate_keys.zip(predicate_key_values(object))
+          else
+            false
+          end
+
+          associated_dataset.where(condition)
         end
 
         ASSOCIATION_DATASET_PROC = proc{|r| r.association_dataset_for(self)}
@@ -241,7 +263,9 @@ module Sequel
         # yielding each row to the block.
         def eager_load_results(eo, &block)
           rows = eo[:rows]
-          initialize_association_cache(rows) unless eo[:initialize_rows] == false
+          unless eo[:initialize_rows] == false
+            Sequel.synchronize_with(eo[:mutex]){initialize_association_cache(rows)}
+          end
           if eo[:id_map]
             ids = eo[:id_map].keys
             return ids if ids.empty?
@@ -250,13 +274,16 @@ module Sequel
           cascade = eo[:associations]
           eager_limit = nil
 
-          if eo[:eager_block] || eo[:loader] == false
+          if eo[:no_results]
+            no_results = true
+          elsif eo[:eager_block] || eo[:loader] == false
             ds = eager_loading_dataset(eo)
 
             strategy = ds.opts[:eager_limit_strategy] || strategy
 
             eager_limit =
               if el = ds.opts[:eager_limit]
+                raise Error, "The :eager_limit dataset option is not supported for associations returning a single record" unless returns_array?
                 strategy ||= true_eager_graph_limit_strategy
                 if el.is_a?(Array)
                   el
@@ -270,6 +297,7 @@ module Sequel
             strategy = true_eager_graph_limit_strategy if strategy == :union
             # Correlated subqueries are not supported for regular eager loading
             strategy = :ruby if strategy == :correlated_subquery
+            strategy = nil if strategy == :ruby && assign_singular?
             objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
           elsif strategy == :union
             objects = []
@@ -287,7 +315,8 @@ module Sequel
             objects = loader.all(ids)
           end
 
-          objects.each(&block)
+          Sequel.synchronize_with(eo[:mutex]){objects.each(&block)} unless no_results
+
           if strategy == :ruby
             apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
           end
@@ -304,11 +333,6 @@ module Sequel
           false
         end
 
-        # Alias of predicate_key, only for backwards compatibility.
-        def eager_loading_predicate_key
-          predicate_key
-        end
-
         # Whether to eagerly graph a lazy dataset, true by default.  If this
         # is false, the association won't respect the :eager_graph option
         # when loading the association for a single record.
@@ -331,6 +355,44 @@ module Sequel
           {filter_by_associations_conditions_key=>ds}
         end
 
+        # Finalize the association by first attempting to populate the thread-safe cache,
+        # and then transfering the thread-safe cache value to the association itself,
+        # so that a mutex is not needed to get the value.
+        def finalize
+          return unless cache = self[:cache]
+
+          finalizer = proc do |meth, key|
+            next if has_key?(key)
+
+            # Allow calling private methods to make sure caching is done appropriately
+            send(meth)
+            self[key] = cache.delete(key) if cache.has_key?(key)
+          end
+
+          finalize_settings.each(&finalizer)
+
+          unless self[:instance_specific]
+            finalizer.call(:associated_eager_dataset, :associated_eager_dataset)
+            finalizer.call(:filter_by_associations_conditions_dataset, :filter_by_associations_conditions_dataset)
+          end
+
+          nil
+        end
+
+        # Map of methods to cache keys used for finalizing associations.
+        FINALIZE_SETTINGS = {
+          :associated_class=>:class,
+          :associated_dataset=>:_dataset,
+          :eager_limit_strategy=>:_eager_limit_strategy,
+          :placeholder_loader=>:placeholder_loader,
+          :predicate_key=>:predicate_key,
+          :predicate_keys=>:predicate_keys,
+          :reciprocal=>:reciprocal,
+        }.freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+    
         # Whether to handle silent modification failure when adding/removing
         # associated records, false by default.
         def handle_silent_modification_failure?
@@ -347,6 +409,18 @@ module Sequel
           end
         end
 
+        # Show which type of reflection this is, and a guess at what code was used to create the
+        # association.
+        def inspect
+          o = self[:orig_opts].dup
+          o.delete(:class)
+          o.delete(:class_name)
+          o.delete(:block) unless o[:block]
+          o[:class] = self[:orig_class] if self[:orig_class]
+
+          "#<#{self.class} #{self[:model]}.#{self[:type]} #{self[:name].inspect}#{", #{o.inspect[1...-1]}" unless o.empty?}>"
+        end
+
         # The limit and offset for this association (returned as a two element array).
         def limit_and_offset
           if (v = self[:limit]).is_a?(Array)
@@ -368,7 +442,11 @@ module Sequel
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
               Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-                ds.where(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)})
+                ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
+                if self[:block]
+                  ds = self[:block].call(ds)
+                end
+                ds
               end
             end
           end
@@ -384,16 +462,14 @@ module Sequel
           predicate_key_methods.map{|k| object.get_column_value(k)}
         end
 
-        # Qualify +col+ with the given table name.  If +col+ is an array of columns,
-        # return an array of qualified columns.  Only qualifies Symbols and SQL::Identifier
-        # values, other values are not modified.
+        # Qualify +col+ with the given table name.
         def qualify(table, col)
           transform(col) do |k|
             case k
             when Symbol, SQL::Identifier
               SQL::QualifiedIdentifier.new(table, k)
             else
-              Sequel::Qualifier.new(self[:model].dataset, table).transform(k)
+              Sequel::Qualifier.new(table).transform(k)
             end
           end
         end
@@ -439,7 +515,7 @@ module Sequel
     
         # Name symbol for the remove_all_ association method
         def remove_all_method
-          :"remove_all_#{self[:name]}"
+          self[:remove_all_method]
         end
       
         # Whether associated objects need to be removed from the association before
@@ -450,7 +526,7 @@ module Sequel
     
         # Name symbol for the remove_ association method
         def remove_method
-          :"remove_#{singularize(self[:name])}"
+          self[:remove_method]
         end
       
         # Whether to check that an object to be disassociated is already associated to this object, false by default.
@@ -477,7 +553,7 @@ module Sequel
     
         # Name symbol for the setter association method
         def setter_method
-          :"#{self[:name]}="
+          self[:setter_method]
         end
         
         # The range used for slicing when using the :ruby eager limit strategy.
@@ -490,8 +566,10 @@ module Sequel
         
         private
 
-        # On non-GVL rubies, assume the need to synchronize access.  Store the key
-        # in a special sub-hash that always uses this method to synchronize access.
+        # If the key exists in the reflection hash, return it.
+        # If the key doesn't exist and association reflections are uncached, then yield to get the value.
+        # If the key doesn't exist and association reflection are cached, check the cache and return
+        # the value if present, or yield to get the value, cache the value, and return it.
         def cached_fetch(key)
           fetch(key) do
             return yield unless h = self[:cache]
@@ -501,7 +579,7 @@ module Sequel
           end
         end
 
-        # Cache the value at the given key, synchronizing access.
+        # Cache the value at the given key if caching.
         def cached_set(key, value)
           return unless h = self[:cache]
           Sequel.synchronize{h[key] = value}
@@ -510,10 +588,10 @@ module Sequel
         # The base dataset used for the association, before any order/conditions
         # options have been applied.
         def _associated_dataset
-          associated_class.dataset.clone
+          associated_class.dataset
         end
 
-        # Whether for the reciprocal type for the given association can not be
+        # Whether for the reciprocal type for the given association cannot be
         # known in advantage, false by default.
         def ambiguous_reciprocal_type?
           false
@@ -562,17 +640,20 @@ module Sequel
         # given the hash passed to the eager loader.
         def eager_loading_dataset(eo=OPTS)
           ds = eo[:dataset] || associated_eager_dataset
-          if id_map = eo[:id_map]
-            ds = ds.where(eager_loading_predicate_condition(id_map.keys))
-          end
+          ds = eager_loading_set_predicate_condition(ds, eo)
           if associations = eo[:associations]
             ds = ds.eager(associations)
           end
           if block = eo[:eager_block]
+            orig_ds = ds
             ds = block.call(ds)
           end
           if eager_loading_use_associated_key?
-            ds = ds.select_append(*associated_key_array)
+            ds = if ds.opts[:eager_graph] && !orig_ds.opts[:eager_graph]
+              block.call(orig_ds.select_append(*associated_key_array))
+            else
+              ds.select_append(*associated_key_array)
+            end
           end
           if self[:eager_graph]
             raise(Error, "cannot eagerly load a #{self[:type]} association that uses :eager_graph") if eager_loading_use_associated_key?
@@ -586,6 +667,15 @@ module Sequel
           self[:model].default_eager_limit_strategy || :ruby
         end
 
+        # Set the predicate condition for the eager loading dataset based on the id map
+        # in the eager loading options.
+        def eager_loading_set_predicate_condition(ds, eo)
+          if id_map = eo[:id_map]
+            ds = ds.where(eager_loading_predicate_condition(id_map.keys))
+          end
+          ds
+        end
+
         # The predicate condition to use for the eager_loader.
         def eager_loading_predicate_condition(keys)
           {predicate_key=>keys}
@@ -630,14 +720,12 @@ module Sequel
           v = fetch(:filter_limit_strategy, self[:eager_limit_strategy])
           if v || self[:limit] || !returns_array?
             case v ||= self[:model].default_eager_limit_strategy
-            when :union, :ruby
+            when true, :union, :ruby
               # Can't use a union or ruby-based strategy for filtering by associations, switch to default eager graph limit
               # strategy.
               true_eager_graph_limit_strategy
             when Symbol
               v
-            when true
-              true_eager_graph_limit_strategy
             end
           end
         end
@@ -685,8 +773,8 @@ module Sequel
 
         # If +s+ is an array, map +s+ over the block.  Otherwise, just call the
         # block with +s+.
-        def transform(s)
-          s.is_a?(Array) ? s.map(&Proc.new) : (yield s)
+        def transform(s, &block)
+          s.is_a?(Array) ? s.map(&block) : (yield s)
         end
 
         # What eager limit strategy should be used when true is given as the value,
@@ -729,7 +817,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          !self[:instance_specific] && !self[:eager_graph]
+          self[:use_placeholder_loader]
         end
       end
     
@@ -774,6 +862,18 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :primary_key=>:primary_key,
+          :primary_keys=>:primary_keys,
+          :primary_key_method=>:primary_key_method,
+          :primary_key_methods=>:primary_key_methods,
+          :qualified_primary_key=>:qualified_primary_key,
+          :reciprocal_type=>:reciprocal_type
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # The expression to use on the left hand side of the IN lookup when eager loading
         def predicate_key
           cached_fetch(:predicate_key){qualified_primary_key}
@@ -918,6 +1018,13 @@ module Sequel
           :"#{underscore(demodulize(self[:model].name))}_id"
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :qualified_primary_key=>:qualified_primary_key
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false.
         def handle_silent_modification_failure?
           self[:raise_on_save_failure] == false
@@ -1023,7 +1130,7 @@ module Sequel
         end
 
         # Support automatic use of correlated subqueries if :ruby option is best available option,
-        # MySQL is not being used, and either the associated class has a non-composite primary key
+        # the database supports them, and either the associated class has a non-composite primary key
         # or the database supports multiple columns in IN.
         def true_eager_graph_limit_strategy
           r = super
@@ -1158,7 +1265,9 @@ module Sequel
             else
               assoc_record.values.delete(left_key_alias)
             end
-            next unless objects = h[hash_key]
+
+            objects = h[hash_key]
+
             if assign_singular
               objects.each do |object| 
                 object.associations[name] ||= assoc_record
@@ -1188,6 +1297,22 @@ module Sequel
           :"#{singularize(self[:name])}_id"
         end
       
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :associated_key_array=>:associated_key_array,
+          :qualified_right_key=>:qualified_right_key,
+          :join_table_source=>:join_table_source,
+          :join_table_alias=>:join_table_alias,
+          :qualified_right_primary_key=>:qualified_right_primary_key,
+          :right_primary_key=>:right_primary_key,
+          :right_primary_keys=>:right_primary_keys,
+          :right_primary_key_method=>:right_primary_key_method,
+          :right_primary_key_methods=>:right_primary_key_methods,
+          :select=>:select
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3)).
         # The left key qualified by the join table.
         def predicate_key
@@ -1202,7 +1327,7 @@ module Sequel
     
         # many_to_many associations need to select a key in an associated table to eagerly load
         def eager_loading_use_associated_key?
-          true
+          !separate_query_per_table?
         end
 
         # The source of the join table.  This is the join table itself, unless it
@@ -1259,10 +1384,30 @@ module Sequel
           cached_fetch(:select){default_select}
         end
 
+        # Whether a separate query should be used for the join table.
+        def separate_query_per_table?
+          self[:join_table_db]
+        end
+
         private
 
+        # Join to the the join table, unless using a separate query per table.
         def _associated_dataset
-          super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
+          if separate_query_per_table?
+            super
+          else
+            super.inner_join(self[:join_table], self[:right_keys].zip(right_primary_keys), :qualify=>:deep)
+          end
+        end
+
+        # Use the right_keys from the eager loading options if
+        # using a separate query per table.
+        def eager_loading_set_predicate_condition(ds, eo)
+          if separate_query_per_table?
+            ds.where(right_primary_key=>eo[:right_keys])
+          else
+            super
+          end
         end
 
         # The default selection for associations that require joins.  These do not use the default
@@ -1353,10 +1498,20 @@ module Sequel
       # This module contains methods added to all association datasets
       module AssociationDatasetMethods
         # The model object that created the association dataset
-        attr_accessor :model_object
+        def model_object
+          @opts[:model_object]
+        end
     
         # The association reflection related to the association dataset
-        attr_accessor :association_reflection
+        def association_reflection
+          @opts[:association_reflection]
+        end
+        
+        private
+
+        def non_sql_option?(key)
+          super || key == :model_object || key == :association_reflection
+        end
       end
       
       # Each kind of association adds a number of instance methods to the model class which
@@ -1397,7 +1552,7 @@ module Sequel
       #   Project.associations
       #   => [:portfolio, :milestones]
       #   Project.association_reflection(:portfolio)
-      #   => {:type => :many_to_one, :name => :portfolio, ...}
+      #   => #<Sequel::Model::Associations::ManyToOneAssociationReflection Project.many_to_one :portfolio>
       #
       # Associations should not have the same names as any of the columns in the
       # model's current table they reference. If you are dealing with an existing schema that
@@ -1419,13 +1574,19 @@ module Sequel
 
         # Whether association metadata should be cached in the association reflection.  If not cached, it will be computed
         # on demand.  In general you only want to set this to false when using code reloading.  When using code reloading,
-        # setting this will make sure that if an associated class is removed or modified, this class will not hang on to
+        # setting this will make sure that if an associated class is removed or modified, this class will not have a reference to
         # the previous class.
         attr_accessor :cache_associations
 
-        # The default options to use for all associations.
+        # The default options to use for all associations.  This hash is merged into the association reflection hash for
+        # all association reflections.
         attr_accessor :default_association_options
 
+        # The default options to use for all associations of a given type.  This is a hash keyed by association type
+        # symbol.  If there is a value for the association type symbol key, the resulting hash will be merged into the
+        # association reflection hash for all association reflections of that type.
+        attr_accessor :default_association_type_options
+
         # The default :eager_limit_strategy option to use for limited or offset associations (default: true, causing Sequel
         # to use what it considers the most appropriate strategy).
         attr_accessor :default_eager_limit_strategy
@@ -1463,6 +1624,7 @@ module Sequel
         # === Multiple Types
         # :adder :: Proc used to define the private _add_* method for doing the database work
         #           to associate the given object to the current object (*_to_many assocations).
+        #           Set to nil to not define a add_* method for the association.
         # :after_add :: Symbol, Proc, or array of both/either specifying a callback to call
         #               after a new item is added to the association.
         # :after_load :: Symbol, Proc, or array of both/either specifying a callback to call
@@ -1473,6 +1635,8 @@ module Sequel
         #               after an item is set using the association setter method.
         # :allow_eager :: If set to false, you cannot load the association eagerly
         #                 via eager or eager_graph
+        # :allow_eager_graph :: If set to false, you cannot load the association eagerly via eager_graph.
+        # :allow_filtering_by :: If set to false, you cannot use the association when filtering
         # :before_add :: Symbol, Proc, or array of both/either specifying a callback to call
         #                before a new item is added to the association.
         # :before_remove :: Symbol, Proc, or array of both/either specifying a callback to call
@@ -1488,16 +1652,22 @@ module Sequel
         #           singularized unless the type is :many_to_one, :one_to_one, or one_through_one).  If this is specified
         #           as a string or symbol, you must specify the full class name (e.g. "::SomeModule::MyModel"). 
         # :class_namespace :: If :class is given as a string or symbol, sets the default namespace in which to look for
-        #                     the class.  <tt>:class=>'Foo', :class_namespace=>'Bar'</tt> looks for <tt>::Bar::Foo</tt>.)
+        #                     the class.  <tt>class: 'Foo', class_namespace: 'Bar'</tt> looks for <tt>::Bar::Foo</tt>.)
         # :clearer :: Proc used to define the private _remove_all_* method for doing the database work
         #             to remove all objects associated to the current object (*_to_many assocations).
+        #             Set to nil to not define a remove_all_* method for the association.
         # :clone :: Merge the current options and block into the options and block used in defining
         #           the given association.  Can be used to DRY up a bunch of similar associations that
         #           all share the same options such as :class and :key, while changing the order and block used.
         # :conditions :: The conditions to use to filter the association, can be any argument passed to where.
-        # :dataset :: A proc that is instance_execed to get the base dataset to use (before the other
+        #                This option is not respected when using eager_graph or association_join, unless it
+        #                is hash or array of two element arrays.  Consider also specifying the :graph_block
+        #                option if the value for this option is not a hash or array of two element arrays
+        #                and you plan to use this association in eager_graph or association_join.
+        # :dataset :: A proc that is used to define the method to get the base dataset to use (before the other
         #             options are applied).  If the proc accepts an argument, it is passed the related
-        #             association reflection.
+        #             association reflection.  It is a best practice to always have the dataset accept an argument
+        #             and use the argument to return the appropriate dataset.
         # :distinct :: Use the DISTINCT clause when selecting associating object, both when
         #              lazy loading and eager loading via .eager (but not when using .eager_graph).
         # :eager :: The associations to eagerly load via +eager+ when loading the associated object(s).
@@ -1540,31 +1710,37 @@ module Sequel
         # :graph_only_conditions :: The conditions to use on the SQL join when eagerly loading
         #                           the association via +eager_graph+, instead of the default conditions specified by the
         #                           foreign/primary keys.  This option causes the :graph_conditions option to be ignored.
-        # :graph_order :: Over the order to use when using eager_graph, instead of the default order.  This should be used
+        # :graph_order :: the order to use when using eager_graph, instead of the default order.  This should be used
         #                 in the case where :order contains an identifier qualified by the table's name, which may not match
         #                 the alias used when eager graphing.  By setting this to the unqualified identifier, it will be
         #                 automatically qualified when using eager_graph.
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
+        # :instance_specific :: Marks the association as instance specific. Should be used if the association block
+        #                       uses instance specific state, or transient state (accessing current date/time, etc.).
         # :limit :: Limit the number of records to the provided value.  Use
         #           an array with two elements for the value to specify a
         #           limit (first element) and an offset (second element).
         # :methods_module :: The module that methods the association creates will be placed into. Defaults
         #                    to the module containing the model's columns.
+        # :no_association_method :: Do not add a method for the association. This can save memory if the association
+        #                           method is never used.
+        # :no_dataset_method :: Do not add a method for the association dataset. This can save memory if the dataset
+        #                       method is never used.
         # :order :: the column(s) by which to order the association dataset.  Can be a
         #           singular column symbol or an array of column symbols.
         # :order_eager_graph :: Whether to add the association's order to the graphed dataset's order when graphing
         #                       via +eager_graph+.  Defaults to true, so set to false to disable.
         # :read_only :: Do not add a setter method (for many_to_one or one_to_one associations),
-        #               or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations). Always
-        #               true for one_through_one associations.
+        #               or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations).
         # :reciprocal :: the symbol name of the reciprocal association,
         #                if it exists.  By default, Sequel will try to determine it by looking at the
         #                associated model's assocations for a association that matches
         #                the current association's key(s).  Set to nil to not use a reciprocal.
         # :remover :: Proc used to define the private _remove_* method for doing the database work
         #             to remove the association between the given object and the current object (*_to_many assocations).
+        #             Set to nil to not define a remove_* method for the association.
         # :select :: the columns to select.  Defaults to the associated class's table_name.* in an association
         #            that uses joins, which means it doesn't include the attributes from the
         #            join table.  If you want to include the join table attributes, you can
@@ -1573,6 +1749,7 @@ module Sequel
         #            the same name in both the join table and the associated table.
         # :setter :: Proc used to define the private _*= method for doing the work to setup the assocation
         #            between the given object and the current object (*_to_one associations).
+        #            Set to nil to not define a setter method for the association.
         # :subqueries_per_union :: The number of subqueries to use in each UNION query, for eager
         #                          loading limited associations using the default :union strategy.
         # :validate :: Set to false to not validate when implicitly saving any associated object.
@@ -1589,7 +1766,7 @@ module Sequel
         #                 array of symbols for a composite key association.
         # :primary_key_method :: the method symbol or array of method symbols to call on the associated
         #                        object to get the foreign key values.  Defaults to :primary_key option.
-        # :qualify :: Whether to use qualifier primary keys when loading the association.  The default
+        # :qualify :: Whether to use qualified primary keys when loading the association.  The default
         #             is true, so you must set to false to not qualify.  Qualification rarely causes
         #             problems, but it's necessary to disable in some cases, such as when you are doing
         #             a JOIN USING operation on the column on Oracle.
@@ -1629,6 +1806,9 @@ module Sequel
         #                underscored, sorted, and joined with '_'.
         # :join_table_block :: proc that can be used to modify the dataset used in the add/remove/remove_all
         #                      methods.  Should accept a dataset argument and return a modified dataset if present.
+        # :join_table_db :: When retrieving records when using lazy loading or eager loading via +eager+, instead of
+        #                   a join between to the join table and the associated table, use a separate query for the
+        #                   join table using the given Database object.
         # :left_key :: foreign key in join table that points to current model's
         #              primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".
         #              Can use an array of symbols for a composite key association.
@@ -1650,7 +1830,7 @@ module Sequel
         #                              Defaults to :right_primary_key option.
         # :uniq :: Adds a after_load callback that makes the array of objects unique.
         def associate(type, name, opts = OPTS, &block)
-          raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
+          raise(Error, 'invalid association type') unless assoc_class = Sequel.synchronize{ASSOCIATION_TYPES[type]}
           raise(Error, 'Model.associate name argument must be a symbol') unless name.is_a?(Symbol)
 
           # dup early so we don't modify opts
@@ -1658,16 +1838,35 @@ module Sequel
 
           if opts[:clone]
             cloned_assoc = association_reflection(opts[:clone])
+            remove_class_name = orig_opts[:class] && !orig_opts[:class_name]
             orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
+            orig_opts.delete(:class_name) if remove_class_name
           end
 
-          opts = default_association_options.merge(orig_opts).merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+          opts = Hash[default_association_options]
+          if type_options = default_association_type_options[type]
+            opts.merge!(type_options)
+          end
+          opts.merge!(orig_opts)
+          opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+
           opts[:block] = block if block
-          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block] || orig_opts[:dataset])
+          opts[:instance_specific] = true if orig_opts[:dataset]
+          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block])
             # It's possible the association is instance specific, in that it depends on
             # values other than the foreign key value.  This needs to be checked for
             # in certain places to disable optimizations.
-            opts[:instance_specific] = true
+            opts[:instance_specific] = _association_instance_specific_default(name)
+          end
+          if (orig_opts[:instance_specific] || orig_opts[:dataset]) && !opts.has_key?(:allow_eager) && !opts[:eager_loader]
+            # For associations explicitly marked as instance specific, or that use the
+            # :dataset option, where :allow_eager is not set, and no :eager_loader is
+            # provided, disallow eager loading.  In these cases, eager loading is
+            # unlikely to work.  This is not done for implicit setting of :instance_specific,
+            # because implicit use is done by default for all associations with blocks,
+            # and the vast majority of associations with blocks use the block for filtering
+            # in a manner compatible with eager loading.
+            opts[:allow_eager] = false
           end
           opts = assoc_class.new.merge!(opts)
 
@@ -1675,10 +1874,8 @@ module Sequel
             raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
           end
 
+          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph]
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
-          if !opts.has_key?(:predicate_key) && opts.has_key?(:eager_loading_predicate_key)
-            opts[:predicate_key] = opts[:eager_loading_predicate_key]
-          end
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
           conds = opts[:conditions]
@@ -1686,18 +1883,24 @@ module Sequel
           opts[:graph_conditions] = conds if !opts.include?(:graph_conditions) and Sequel.condition_specifier?(conds)
           opts[:graph_conditions] = opts.fetch(:graph_conditions, []).to_a
           opts[:graph_select] = Array(opts[:graph_select]) if opts[:graph_select]
-          [:before_add, :before_remove, :after_add, :after_remove, :after_load, :before_set, :after_set, :extend].each do |cb_type|
-            opts[cb_type] = Array(opts[cb_type])
+          [:before_add, :before_remove, :after_add, :after_remove, :after_load, :before_set, :after_set].each do |cb_type|
+            opts[cb_type] = Array(opts[cb_type]) if opts[cb_type]
+          end
+
+          if opts[:extend]
+            opts[:extend] = Array(opts[:extend])
+            opts[:reverse_extend] = opts[:extend].reverse
           end
+
           late_binding_class_option(opts, opts.returns_array? ? singularize(name) : name)
           
           # Remove :class entry if it exists and is nil, to work with cached_fetch
           opts.delete(:class) unless opts[:class]
 
-          send(:"def_#{type}", opts)
-          def_association_instance_methods(opts)
+          def_association(opts)
       
           orig_opts.delete(:clone)
+          opts[:orig_class] = orig_opts[:class] || orig_opts[:class_name]
           orig_opts.merge!(:class_name=>opts[:class_name], :class=>opts[:class], :block=>opts[:block])
           opts[:orig_opts] = orig_opts
           # don't add to association_reflections until we are sure there are no errors
@@ -1719,6 +1922,25 @@ module Sequel
           opts.eager_load_results(eo, &block)
         end
 
+        # Freeze association related metadata when freezing model class.
+        def freeze
+          @association_reflections.freeze.each_value(&:freeze)
+          @autoreloading_associations.freeze.each_value(&:freeze)
+          @default_association_options.freeze
+          @default_association_type_options.freeze
+          @default_association_type_options.each_value(&:freeze)
+
+          super
+        end
+
+        # Finalize all associations such that values that are looked up
+        # dynamically in associated classes are set statically.
+        # As this modifies the associations, it must be done before
+        # calling freeze.
+        def finalize_associations
+          @association_reflections.each_value(&:finalize)
+        end
+
         # Shortcut for adding a many_to_many association, see #associate
         def many_to_many(name, opts=OPTS, &block)
           associate(:many_to_many, name, opts, &block)
@@ -1729,7 +1951,7 @@ module Sequel
           associate(:many_to_one, name, opts, &block)
         end
         
-        # Shortcut for adding a one_through_one association, see #associate.
+        # Shortcut for adding a one_through_one association, see #associate
         def one_through_one(name, opts=OPTS, &block)
           associate(:one_through_one, name, opts, &block)
         end
@@ -1739,15 +1961,21 @@ module Sequel
           associate(:one_to_many, name, opts, &block)
         end
 
-        # Shortcut for adding a one_to_one association, see #associate.
+        # Shortcut for adding a one_to_one association, see #associate
         def one_to_one(name, opts=OPTS, &block)
           associate(:one_to_one, name, opts, &block)
         end
 
-        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
+        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@default_association_type_options=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
+
+        # The default value for the instance_specific option, if the association
+        # could be instance specific and the :instance_specific option is not specified.
+        def _association_instance_specific_default(_)
+          true
+        end
       
         # The module to use for the association's methods.  Defaults to
         # the overridable_methods_module.
@@ -1759,7 +1987,22 @@ module Sequel
         # can be easily overridden in the class itself while allowing for
         # super to be called.
         def association_module_def(name, opts=OPTS, &block)
-          association_module(opts).module_eval{define_method(name, &block)}
+          mod = association_module(opts)
+          mod.send(:define_method, name, &block)
+          mod.send(:alias_method, name, name)
+        end
+
+        # Add a method to the module included in the class, so the method
+        # can be easily overridden in the class itself while allowing for
+        # super to be called.  This method allows passing keywords through
+        # the defined methods.
+        def association_module_delegate_def(name, opts, &block)
+          mod = association_module(opts)
+          mod.send(:define_method, name, &block)
+          # :nocov:
+          mod.send(:ruby2_keywords, name) if mod.respond_to?(:ruby2_keywords, true)
+          # :nocov:
+          mod.send(:alias_method, name, name)
         end
       
         # Add a private method to the module included in the class.
@@ -1768,37 +2011,67 @@ module Sequel
           association_module(opts).send(:private, name)
         end
 
+        # Delegate to the type-specific association method to setup the
+        # association, and define the association instance methods.
+        def def_association(opts)
+          send(:"def_#{opts[:type]}", opts)
+          def_association_instance_methods(opts)
+        end
+        
         # Adds the association method to the association methods module.
         def def_association_method(opts)
-          association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
+          association_module_def(opts.association_method, opts) do |dynamic_opts=OPTS, &block|
+            load_associated_objects(opts, dynamic_opts, &block)
+          end
         end
       
         # Define all of the association instance methods for this association.
         def def_association_instance_methods(opts)
-          association_module_def(opts.dataset_method, opts){_dataset(opts)}
-          def_association_method(opts)
+          # Always set the method names in the association reflection, even if they
+          # are not used, for backwards compatibility.
+          opts[:dataset_method] = :"#{opts[:name]}_dataset"
+          if opts.returns_array?
+            sname = singularize(opts[:name])
+            opts[:_add_method] = :"_add_#{sname}"
+            opts[:add_method] = :"add_#{sname}"
+            opts[:_remove_method] = :"_remove_#{sname}"
+            opts[:remove_method] = :"remove_#{sname}"
+            opts[:_remove_all_method] = :"_remove_all_#{opts[:name]}"
+            opts[:remove_all_method] = :"remove_all_#{opts[:name]}"
+          else
+            opts[:_setter_method] = :"_#{opts[:name]}="
+            opts[:setter_method] = :"#{opts[:name]}="
+          end
+
+          association_module_def(opts.dataset_method, opts){_dataset(opts)} unless opts[:no_dataset_method]
+          if opts[:block]
+            opts[:block_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_block", 1, &opts[:block])
+          end
+          opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
+          opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
+          def_association_method(opts) unless opts[:no_association_method]
 
           return if opts[:read_only]
 
           if opts[:setter] && opts[:_setter]
             # This is backwards due to backwards compatibility
-            association_module_private_def(opts._setter_method, opts, &opts[:setter])
-            association_module_def(opts.setter_method, opts, &opts[:_setter])
+            association_module_private_def(opts[:_setter_method], opts, &opts[:setter])
+            association_module_def(opts[:setter_method], opts, &opts[:_setter])
           end
 
           if adder = opts[:adder]
-            association_module_private_def(opts._add_method, opts, &adder)
-            association_module_def(opts.add_method, opts){|o,*args| add_associated_object(opts, o, *args)}
+            association_module_private_def(opts[:_add_method], opts, &adder)
+            association_module_delegate_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
           end
 
           if remover = opts[:remover]
-            association_module_private_def(opts._remove_method, opts, &remover)
-            association_module_def(opts.remove_method, opts){|o,*args| remove_associated_object(opts, o, *args)}
+            association_module_private_def(opts[:_remove_method], opts, &remover)
+            association_module_delegate_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
           end
 
           if clearer = opts[:clearer]
-            association_module_private_def(opts._remove_all_method, opts, &clearer)
-            association_module_def(opts.remove_all_method, opts){|*args| remove_all_associated_objects(opts, *args)}
+            association_module_private_def(opts[:_remove_all_method], opts, &clearer)
+            association_module_delegate_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
           end
         end
         
@@ -1820,14 +2093,84 @@ module Sequel
             raise(Error, "mismatched number of right keys: #{rcks.inspect} vs #{rcpks.inspect}") unless rcks.length == rcpks.length
           end
           opts[:uses_left_composite_keys] = lcks.length > 1
-          opts[:uses_right_composite_keys] = rcks.length > 1
+          uses_rcks = opts[:uses_right_composite_keys] = rcks.length > 1
           opts[:cartesian_product_number] ||= one_through_one ? 0 : 1
           join_table = (opts[:join_table] ||= opts.default_join_table)
           opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
-          opts[:dataset] ||= opts.association_dataset_proc
-          opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
+          if join_table_db = opts[:join_table_db]
+            opts[:use_placeholder_loader] = false
+            opts[:allow_eager_graph] = false
+            opts[:allow_filtering_by] = false
+            opts[:eager_limit_strategy] = nil
+            join_table_ds = join_table_db.from(join_table)
+            opts[:dataset] ||= proc do |r|
+              vals = join_table_ds.where(lcks.zip(lcpks.map{|k| get_column_value(k)})).select_map(right)
+              ds = r.associated_dataset.where(opts.right_primary_key => vals)
+              if uses_rcks
+                vals.delete_if{|v| v.any?(&:nil?)}
+              else
+                vals.delete(nil)
+              end
+              ds = ds.clone(:no_results=>true) if vals.empty?
+              ds
+            end
+            opts[:eager_loader] ||= proc do |eo|
+              h = eo[:id_map]
+              assign_singular = opts.assign_singular?
+              rpk = opts.right_primary_key
+              name = opts[:name]
+
+              join_map = join_table_ds.where(left=>h.keys).select_hash_groups(right, left)
+
+              if uses_rcks
+                join_map.delete_if{|v,| v.any?(&:nil?)}
+              else
+                join_map.delete(nil)
+              end
+
+              eo = Hash[eo]
+
+              if join_map.empty?
+                eo[:no_results] = true
+              else
+                join_map.each_value do |vs|
+                  vs.replace(vs.flat_map{|v| h[v]})
+                  vs.uniq!
+                end
+
+                eo[:loader] = false
+                eo[:right_keys] = join_map.keys
+              end
+
+              opts[:model].eager_load_results(opts, eo) do |assoc_record|
+                rpkv = if uses_rcks
+                  assoc_record.values.values_at(*rpk)
+                else
+                  assoc_record.values[rpk]
+                end
+
+                objects = join_map[rpkv]
+
+                if assign_singular
+                  objects.each do |object|
+                    object.associations[name] ||= assoc_record
+                  end
+                else
+                  objects.each do |object|
+                    object.associations[name].push(assoc_record)
+                  end
+                end
+              end
+            end
+          else
+            opts[:dataset] ||= opts.association_dataset_proc
+            opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          end
           
           join_type = opts[:graph_join_type]
           select = opts[:graph_select]
@@ -1861,50 +2204,60 @@ module Sequel
           return if opts[:read_only]
       
           if one_through_one
-            opts[:setter] ||= proc do |o|
-              h = {}
-              lh = lcks.zip(lcpks.map{|k| get_column_value(k)})
-              jtds = _join_table_dataset(opts).where(lh)
-
-              checked_transaction do
-                current = jtds.first
+            unless opts.has_key?(:setter)
+              opts[:setter] = proc do |o|
+                h = {}
+                lh = lcks.zip(lcpks.map{|k| get_column_value(k)})
+                jtds = _join_table_dataset(opts).where(lh)
 
-                if o
-                  new_values = []
-                  rcks.zip(opts.right_primary_key_methods).each{|k, pk| new_values << (h[k] = o.get_column_value(pk))}
-                end
+                checked_transaction do
+                  current = jtds.first
 
-                if current
-                  current_values = rcks.map{|k| current[k]}
-                  jtds = jtds.where(rcks.zip(current_values))
                   if o
-                    if current_values != new_values
-                      jtds.update(h)
+                    new_values = []
+                    rcks.zip(opts.right_primary_key_methods).each{|k, pk| new_values << (h[k] = o.get_column_value(pk))}
+                  end
+
+                  if current
+                    current_values = rcks.map{|k| current[k]}
+                    jtds = jtds.where(rcks.zip(current_values))
+                    if o
+                      if current_values != new_values
+                        jtds.update(h)
+                      end
+                    else
+                      jtds.delete
                     end
-                  else
-                    jtds.delete
+                  elsif o
+                    lh.each{|k,v| h[k] = v}
+                    jtds.insert(h)
                   end
-                elsif o
-                  lh.each{|k,v| h[k] = v}
-                  jtds.insert(h)
                 end
               end
             end
-            opts[:_setter] = proc{|o| set_one_through_one_associated_object(opts, o)}
+            if opts.fetch(:setter, true)
+              opts[:_setter] = proc{|o| set_one_through_one_associated_object(opts, o)}
+            end
           else 
-            opts[:adder] ||= proc do |o|
-              h = {}
-              lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
-              rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
-              _join_table_dataset(opts).insert(h)
+            unless opts.has_key?(:adder)
+              opts[:adder] = proc do |o|
+                h = {}
+                lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
+                rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
+                _join_table_dataset(opts).insert(h)
+              end
             end
 
-            opts[:remover] ||= proc do |o|
-              _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
+            unless opts.has_key?(:remover)
+              opts[:remover] = proc do |o|
+                _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
+              end
             end
 
-            opts[:clearer] ||= proc do
-              _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
+            unless opts.has_key?(:clearer)
+              opts[:clearer] = proc do
+                _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
+              end
             end
           end
         end
@@ -1943,9 +2296,7 @@ module Sequel
 
             eager_load_results(opts, eo) do |assoc_record|
               hash_key = uses_cks ? pk_meths.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(opts.primary_key_method)
-              if objects = h[hash_key]
-                objects.each{|object| object.associations[name] = assoc_record}
-              end
+              h[hash_key].each{|object| object.associations[name] = assoc_record}
             end
           end
       
@@ -1958,13 +2309,17 @@ module Sequel
           graph_cks = opts[:graph_keys]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
           end
       
           return if opts[:read_only]
       
-          opts[:setter] ||= proc{|o| cks.zip(opts.primary_key_methods).each{|k, pk| set_column_value(:"#{k}=", (o.get_column_value(pk) if o))}}
-          opts[:_setter] = proc{|o| set_associated_object(opts, o)}
+          unless opts.has_key?(:setter)
+            opts[:setter] = proc{|o| cks.zip(opts.primary_key_methods).each{|k, pk| set_column_value(:"#{k}=", (o.get_column_value(pk) if o))}}
+          end
+          if opts.fetch(:setter, true)
+            opts[:_setter] = proc{|o| set_associated_object(opts, o)}
+          end
         end
         
         # Configures one_to_many and one_to_one association reflections and adds the related association methods
@@ -1992,7 +2347,7 @@ module Sequel
             eager_load_results(opts, eo) do |assoc_record|
               assoc_record.values.delete(delete_rn) if delete_rn
               hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
-              next unless objects = h[hash_key]
+              objects = h[hash_key]
               if assign_singular
                 objects.each do |object| 
                   unless object.associations[name]
@@ -2018,7 +2373,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -2031,33 +2386,59 @@ module Sequel
           cks.each{|k| ck_nil_hash[k] = nil}
 
           if one_to_one
-            opts[:setter] ||= proc do |o|
-              up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
-              if o
-                up_ds = up_ds.exclude(o.pk_hash) unless o.new?
-                cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
-              end
-              checked_transaction do
-                up_ds.update(ck_nil_hash)
-                o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
+            unless opts.has_key?(:setter)
+              opts[:setter] = proc do |o|
+                up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
+
+                if (froms = up_ds.opts[:from]) && (from = froms[0]) && (from.is_a?(Sequel::Dataset) || (from.is_a?(Sequel::SQL::AliasedExpression) && from.expression.is_a?(Sequel::Dataset)))
+                  if old = up_ds.first
+                    cks.each{|k| old.set_column_value(:"#{k}=", nil)}
+                  end
+                  save_old = true
+                end
+
+                if o
+                  if !o.new? && !save_old
+                    up_ds = up_ds.exclude(o.pk_hash)
+                  end
+                  cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
+                end
+
+                checked_transaction do
+                  if save_old
+                    old.save(save_opts) || raise(Sequel::Error, "invalid previously associated object, cannot save") if old
+                  else
+                    up_ds.skip_limit_check.update(ck_nil_hash)
+                  end
+
+                  o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
+                end
               end
             end
-            opts[:_setter] = proc{|o| set_one_to_one_associated_object(opts, o)}
+            if opts.fetch(:setter, true)
+              opts[:_setter] = proc{|o| set_one_to_one_associated_object(opts, o)}
+            end
           else 
             save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
-            opts[:adder] ||= proc do |o|
-              cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
-              o.save(save_opts)
+            unless opts.has_key?(:adder)
+              opts[:adder] = proc do |o|
+                cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
+                o.save(save_opts)
+              end
             end
     
-            opts[:remover] ||= proc do |o|
-              cks.each{|k| o.set_column_value(:"#{k}=", nil)}
-              o.save(save_opts)
+            unless opts.has_key?(:remover)
+              opts[:remover] = proc do |o|
+                cks.each{|k| o.set_column_value(:"#{k}=", nil)}
+                o.save(save_opts)
+              end
             end
 
-            opts[:clearer] ||= proc do
-              _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)}))).update(ck_nil_hash)
+            unless opts.has_key?(:clearer)
+              opts[:clearer] = proc do
+                _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)}))).update(ck_nil_hash)
+              end
             end
           end
         end
@@ -2101,8 +2482,10 @@ module Sequel
         # retrieving associations after freezing will still work in most cases,
         # but the associations will not be cached in the association cache.
         def freeze
-          associations.freeze
+          associations
           super
+          associations.freeze
+          self
         end
       
         private
@@ -2112,15 +2495,16 @@ module Sequel
           unless ds.kind_of?(AssociationDatasetMethods)
             ds = opts.apply_dataset_changes(ds)
           end
-          ds.model_object = self
+          ds = ds.clone(:model_object => self)
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
-          ds = instance_exec(ds, &opts[:block]) if opts[:block]
+          # block method is private
+          ds = send(opts[:block_method], ds) if opts[:block_method]
           ds
         end
 
         # Return a dataset for the association after applying any dynamic callback.
         def _associated_dataset(opts, dynamic_opts)
-          ds = send(opts.dataset_method)
+          ds = public_send(opts.dataset_method)
           if callback = dynamic_opts[:callback]
             ds = callback.call(ds)
           end
@@ -2137,17 +2521,18 @@ module Sequel
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          ds = if opts[:dataset].arity == 1
-            instance_exec(opts, &opts[:dataset])
+          ds = if opts[:dataset_opt_arity] == 1
+            # dataset_opt_method is private
+            send(opts[:dataset_opt_method], opts)
           else
-            instance_exec(&opts[:dataset])
+            send(opts[:dataset_opt_method])
           end
           _apply_association_options(opts, ds)
         end
 
         # Dataset for the join table of the given many to many association reflection
         def _join_table_dataset(opts)
-          ds = model.db.from(opts.join_table_source)
+          ds = (opts[:join_table_db] || model.db).from(opts.join_table_source)
           opts[:join_table_block] ? opts[:join_table_block].call(ds) : ds
         end
 
@@ -2168,7 +2553,12 @@ module Sequel
           if loader = _associated_object_loader(opts, dynamic_opts)
             loader.all(*opts.predicate_key_values(self))
           else
-            _associated_dataset(opts, dynamic_opts).all
+            ds = _associated_dataset(opts, dynamic_opts)
+            if ds.opts[:no_results]
+              []
+            else
+              ds.all
+            end
           end
         end
 
@@ -2200,7 +2590,8 @@ module Sequel
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
           ensure_associated_primary_key(opts, o, *args)
           return if run_association_callbacks(opts, :before_add, o) == false
-          return if !send(opts._add_method, o, *args) && opts.handle_silent_modification_failure?
+          # Allow calling private _add method
+          return if !send(opts[:_add_method], o, *args) && opts.handle_silent_modification_failure?
           if array = associations[opts[:name]] and !array.include?(o)
             array.push(o)
           end
@@ -2208,6 +2599,9 @@ module Sequel
           run_association_callbacks(opts, :after_add, o)
           o
         end
+        # :nocov:
+        ruby2_keywords(:add_associated_object) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Add/Set the current object to/as the given object's reciprocal association.
         def add_reciprocal_object(opts, o)
@@ -2232,7 +2626,32 @@ module Sequel
         # cached associations.
         def change_column_value(column, value)
           if assocs = model.autoreloading_associations[column]
-            assocs.each{|a| associations.delete(a)}
+            vals = @values
+            if new?
+              # Do deeper checking for new objects, so that associations are
+              # not deleted when values do not change.  This code is run at
+              # a higher level for existing objects.
+              if value == (c = vals[column]) && value.class == c.class
+                # If the value is the same, there is no reason to delete
+                # the related associations, so exit early in that case.
+                return super
+              end
+
+              only_delete_nil = c.nil?
+            elsif vals[column].nil?
+              only_delete_nil = true
+            end
+
+            if only_delete_nil
+              # If the current foreign key value is nil, but the association
+              # is already present in the cache, it was probably added to the
+              # cache for a reason, and we do not want to delete it in that case.
+              # However, we still want to delete associations with nil values
+              # to remove the cached false negative.
+              assocs.each{|a| associations.delete(a) if associations[a].nil?}
+            else
+              assocs.each{|a| associations.delete(a)}
+            end
           end
           super
         end
@@ -2254,25 +2673,10 @@ module Sequel
           self
         end
 
-        # Handle parsing of options when loading associations.  For historical
-        # reasons, you can pass true/false/nil or a callable argument to
-        # associations.  That will be going away in Sequel 5, but we'll still
-        # support it until then.
+        # If a block is given, assign it as the :callback option in the hash, and return the hash.
         def load_association_objects_options(dynamic_opts, &block)
-          dynamic_opts = case dynamic_opts
-          when true, false, nil
-            {:reload=>dynamic_opts}
-          when Hash
-            Hash[dynamic_opts]
-          else
-            if dynamic_opts.respond_to?(:call)
-              {:callback=>dynamic_opts}
-            else
-              {:reload=>true}
-            end
-          end
-
-          if block_given?
+          if block
+            dynamic_opts = Hash[dynamic_opts]
             dynamic_opts[:callback] = block
           end
 
@@ -2280,7 +2684,7 @@ module Sequel
         end
 
         # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
-        def load_associated_objects(opts, dynamic_opts=nil, &block)
+        def load_associated_objects(opts, dynamic_opts, &block)
           dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
           if associations.include?(name) && !dynamic_opts[:callback] && !dynamic_opts[:reload]
@@ -2334,11 +2738,15 @@ module Sequel
         # Remove all associated objects from the given association
         def remove_all_associated_objects(opts, *args)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          send(opts._remove_all_method, *args)
+          # Allow calling private _remove_all method
+          send(opts[:_remove_all_method], *args)
           ret = associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if associations.include?(opts[:name])
           associations[opts[:name]] = []
           ret
         end
+        # :nocov:
+        ruby2_keywords(:remove_all_associated_objects) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Remove the given associated object from the given association
         def remove_associated_object(opts, o, *args)
@@ -2347,18 +2755,22 @@ module Sequel
             o = remove_check_existing_object_from_pk(opts, o, *args)
           elsif !o.is_a?(klass)
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
-          elsif opts.remove_should_check_existing? && send(opts.dataset_method).where(o.pk_hash).empty?
+          elsif opts.remove_should_check_existing? && public_send(opts.dataset_method).where(o.pk_hash).empty?
             raise(Sequel::Error, "associated object #{o.inspect} is not currently associated to #{inspect}")
           end
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
           raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
           return if run_association_callbacks(opts, :before_remove, o) == false
-          return if !send(opts._remove_method, o, *args) && opts.handle_silent_modification_failure?
+          # Allow calling private _remove method
+          return if !send(opts[:_remove_method], o, *args) && opts.handle_silent_modification_failure?
           associations[opts[:name]].delete_if{|x| o === x} if associations.include?(opts[:name])
           remove_reciprocal_object(opts, o)
           run_association_callbacks(opts, :after_remove, o)
           o
         end
+        # :nocov:
+        ruby2_keywords(:remove_associated_object) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
 
         # Check that the object from the associated table specified by the primary key
         # is currently associated to the receiver.  If it is associated, return the object, otherwise
@@ -2366,7 +2778,7 @@ module Sequel
         def remove_check_existing_object_from_pk(opts, o, *args)
           key = o
           pkh = opts.associated_class.qualified_primary_key_hash(key)
-          raise(Sequel::Error, "no object with key(s) #{key.inspect} is currently associated to #{inspect}") unless o = send(opts.dataset_method).first(pkh)
+          raise(Sequel::Error, "no object with key(s) #{key.inspect} is currently associated to #{inspect}") unless o = public_send(opts.dataset_method).first(pkh)
           o
         end
 
@@ -2384,40 +2796,52 @@ module Sequel
 
         # Run the callback for the association with the object.
         def run_association_callbacks(reflection, callback_type, object)
-          # The reason we automatically set raise_error for singular associations is that
-          # assignment in ruby always returns the argument instead of the result of the
-          # method, so we can't return nil to signal that the association callback prevented
-          # the modification
-          raise_error = raise_on_save_failure || !reflection.returns_array?
-          stop_on_false = [:before_add, :before_remove, :before_set].include?(callback_type)
-          reflection[callback_type].each do |cb|
-            res = case cb
-            when Symbol
-              send(cb, object)
-            when Proc
-              cb.call(self, object)
-            else
-              raise Error, "callbacks should either be Procs or Symbols"
-            end
-
-            if res == false and stop_on_false
-              raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false")
+          return unless cbs = reflection[callback_type]
+
+          begin
+            cbs.each do |cb|
+              case cb
+              when Symbol
+                # Allow calling private methods in association callbacks
+                send(cb, object)
+              when Proc
+                cb.call(self, object)
+              else
+                raise Error, "callbacks should either be Procs or Symbols"
+              end
             end
+          rescue HookFailed
+            # The reason we automatically set raise_error for singular associations is that
+            # assignment in ruby always returns the argument instead of the result of the
+            # method, so we can't return nil to signal that the association callback prevented
+            # the modification
+            return false unless raise_on_save_failure || !reflection.returns_array?
+            raise
           end
-        rescue HookFailed
-          return false unless raise_error
-          raise
         end
 
         # Set the given object as the associated object for the given *_to_one association reflection
         def _set_associated_object(opts, o)
           a = associations[opts[:name]]
-          return if a && a == o && !set_associated_object_if_same?
+          reciprocal = opts.reciprocal
+          if set_associated_object_if_same?
+            if reciprocal
+              remove_reciprocal = a && (a != o || a.associations[reciprocal] != self)
+              add_reciprocal = o && o.associations[reciprocal] != self
+            end
+          else
+            return if a && a == o
+            if reciprocal
+              remove_reciprocal = a
+              add_reciprocal = o
+            end
+          end
           run_association_callbacks(opts, :before_set, o)
-          remove_reciprocal_object(opts, a) if a
-          send(opts._setter_method, o)
+          remove_reciprocal_object(opts, a) if remove_reciprocal
+          # Allow calling private _setter method
+          send(opts[:_setter_method], o)
           associations[opts[:name]] = o
-          add_reciprocal_object(opts, o) if o
+          add_reciprocal_object(opts, o) if add_reciprocal
           run_association_callbacks(opts, :after_set, o)
           o
         end
@@ -2472,48 +2896,112 @@ module Sequel
       #   Album.eager(:artist, :genre).all
       #   Album.eager_graph(:artist, :genre).all
       #   Album.eager(:artist).eager(:genre).all
-      #   Album.eager_graph(:artist).eager(:genre).all
-      #   Artist.eager(:albums=>:tracks).all
-      #   Artist.eager_graph(:albums=>:tracks).all
-      #   Artist.eager(:albums=>{:tracks=>:genre}).all
-      #   Artist.eager_graph(:albums=>{:tracks=>:genre}).all
+      #   Album.eager_graph(:artist).eager_graph(:genre).all
+      #   Artist.eager(albums: :tracks).all
+      #   Artist.eager_graph(albums: :tracks).all
+      #   Artist.eager(albums: {tracks: :genre}).all
+      #   Artist.eager_graph(albums: {tracks: :genre}).all
       #
       # You can also pass a callback as a hash value in order to customize the dataset being
       # eager loaded at query time, analogous to the way the :eager_block association option
       # allows you to customize it at association definition time. For example,
       # if you wanted artists with their albums since 1990:
       #
-      #   Artist.eager(:albums => proc{|ds| ds.where{year > 1990}})
+      #   Artist.eager(albums: proc{|ds| ds.where{year > 1990}})
       #
       # Or if you needed albums and their artist's name only, using a single query:
       #
-      #   Albums.eager_graph(:artist => proc{|ds| ds.select(:name)})
+      #   Albums.eager_graph(artist: proc{|ds| ds.select(:name)})
       #
       # To cascade eager loading while using a callback, you substitute the cascaded
       # associations with a single entry hash that has the proc callback as the key and 
       # the cascaded associations as the value.  This will load artists with their albums
       # since 1990, and also the tracks on those albums and the genre for those tracks:
       #
-      #   Artist.eager(:albums => {proc{|ds| ds.where{year > 1990}}=>{:tracks => :genre}})
+      #   Artist.eager(albums: {proc{|ds| ds.where{year > 1990}}=>{tracks: :genre}})
       module DatasetMethods
-        Sequel::Dataset.def_mutation_method(:eager, :eager_graph, :module=>self)
-
         %w'inner left right full'.each do |type|
-          class_eval <<END, __FILE__, __LINE__+1
+          class_eval(<<-END, __FILE__, __LINE__+1)
             def association_#{type}_join(*associations)
               _association_join(:#{type}, associations)
             end
-END
+          END
         end
 
         # Adds one or more INNER JOINs to the existing dataset using the keys and conditions
-        # specified by the given association.  The following methods also exist for specifying
-        # a different type of JOIN:
+        # specified by the given association(s).  Take the same arguments as eager_graph, and
+        # operates similarly, but only adds the joins as opposed to making the other changes
+        # (such as adding selected columns and setting up eager loading).
+        #
+        # The following methods also exist for specifying a different type of JOIN:
         #
         # association_full_join :: FULL JOIN
         # association_inner_join :: INNER JOIN
         # association_left_join :: LEFT JOIN
         # association_right_join :: RIGHT JOIN
+        #
+        # Examples:
+        #
+        #   # For each album, association_join load the artist
+        #   Album.association_join(:artist).all
+        #   # SELECT *
+        #   # FROM albums
+        #   # INNER JOIN artists AS artist ON (artists.id = albums.artist_id)
+        #
+        #   # For each album, association_join load the artist, using a specified alias
+        #   Album.association_join(Sequel[:artist].as(:a)).all
+        #   # SELECT *
+        #   # FROM albums
+        #   # INNER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
+        #   # For each album, association_join load the artist and genre
+        #   Album.association_join(:artist, :genre).all
+        #   Album.association_join(:artist).association_join(:genre).all
+        #   # SELECT *
+        #   # FROM albums
+        #   # INNER JOIN artists AS artist ON (artist.id = albums.artist_id)
+        #   # INNER JOIN genres AS genre ON (genre.id = albums.genre_id)
+        #
+        #   # For each artist, association_join load albums and tracks for each album
+        #   Artist.association_join(albums: :tracks).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN tracks ON (tracks.album_id = albums.id)
+        #
+        #   # For each artist, association_join load albums, tracks for each album, and genre for each track
+        #   Artist.association_join(albums: {tracks: :genre}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN tracks ON (tracks.album_id = albums.id)
+        #   # INNER JOIN genres AS genre ON (genre.id = tracks.genre_id)
+        #
+        #   # For each artist, association_join load albums with year > 1990
+        #   Artist.association_join(albums: proc{|ds| ds.where{year > 1990}}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #
+        #   # For each artist, association_join load albums and tracks 1-10 for each album
+        #   Artist.association_join(albums: {tracks: proc{|ds| ds.where(number: 1..10)}}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN (
+        #   #   SELECT * FROM tracks WHERE ((number >= 1) AND (number <= 10))
+        #   # ) AS tracks ON (tracks.albums_id = albums.id)
+        #
+        #   # For each artist, association_join load albums with year > 1990, and tracks for those albums
+        #   Artist.association_join(albums: {proc{|ds| ds.where{year > 1990}}=>:tracks}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN tracks ON (tracks.album_id = albums.id)
         def association_join(*associations)
           association_inner_join(*associations)
         end
@@ -2526,11 +3014,13 @@ END
         # types, this is a simple transformation, but for +many_to_many+ associations this 
         # creates a subquery to the join table.
         def complex_expression_sql_append(sql, op, args)
-          r = args.at(1)
-          if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
-              (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
-            l = args.at(0)
+          r = args[1]
+          if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
+              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
+            l = args[0]
             if ar = model.association_reflections[l]
+              raise Error, "filtering by associations is not allowed for #{ar.inspect}" if ar[:allow_filtering_by] == false
+
               if multiple
                 klass = ar.associated_class
                 if is_ds
@@ -2584,7 +3074,7 @@ END
         # it avoids problems such as aliasing conflicts and creating cartesian product
         # result sets if multiple one_to_many or many_to_many eager associations are requested.
         #
-        # One limitation of using this method is that you cannot filter the dataset
+        # One limitation of using this method is that you cannot filter the current dataset
         # based on values of columns in an associated table, since the associations are loaded
         # in separate queries.  To do that you need to load all associations in the
         # same query, and extract an object graph from the results of that query. If you
@@ -2593,15 +3083,66 @@ END
         #
         # Each association's order, if defined, is respected.
         # If the association uses a block or has an :eager_block argument, it is used.
+        #
+        # To modify the associated dataset that will be used for the eager load, you should use a
+        # hash for the association, with the key being the association name symbol, and the value being
+        # a callable object that is called with the associated dataset and should return a modified
+        # dataset.  If that association also has dependent associations, instead of a callable object,
+        # use a hash with the callable object being the key, and the dependent association(s) as the value.
+        #
+        # Examples:
+        #
+        #   # For each album, eager load the artist
+        #   Album.eager(:artist).all
+        #   # SELECT * FROM albums
+        #   # SELECT * FROM artists WHERE (id IN (...))
+        #
+        #   # For each album, eager load the artist and genre
+        #   Album.eager(:artist, :genre).all
+        #   Album.eager(:artist).eager(:genre).all
+        #   # SELECT * FROM albums
+        #   # SELECT * FROM artists WHERE (id IN (...))
+        #   # SELECT * FROM genres WHERE (id IN (...))
+        #
+        #   # For each artist, eager load albums and tracks for each album
+        #   Artist.eager(albums: :tracks).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
+        #   # SELECT * FROM tracks WHERE (album_id IN (...))
+        #
+        #   # For each artist, eager load albums, tracks for each album, and genre for each track
+        #   Artist.eager(albums: {tracks: :genre}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
+        #   # SELECT * FROM tracks WHERE (album_id IN (...))
+        #   # SELECT * FROM genre WHERE (id IN (...))
+        #
+        #   # For each artist, eager load albums with year > 1990
+        #   Artist.eager(albums: proc{|ds| ds.where{year > 1990}}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE ((year > 1990) AND (artist_id IN (...)))
+        #
+        #   # For each artist, eager load albums and tracks 1-10 for each album
+        #   Artist.eager(albums: {tracks: proc{|ds| ds.where(number: 1..10)}}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
+        #   # SELECT * FROM tracks WHERE ((number >= 1) AND (number <= 10) AND (album_id IN (...)))
+        #
+        #   # For each artist, eager load albums with year > 1990, and tracks for those albums
+        #   Artist.eager(albums: {proc{|ds| ds.where{year > 1990}}=>:tracks}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE ((year > 1990) AND (artist_id IN (...)))
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
         def eager(*associations)
           opts = @opts[:eager]
           association_opts = eager_options_for_associations(associations)
-          opts = opts ? Hash[opts].merge!(association_opts) : association_opts
-          clone(:eager=>opts)
+          opts = opts ? opts.merge(association_opts) : association_opts
+          clone(:eager=>opts.freeze)
         end
 
         # The secondary eager loading method.  Loads all associations in a single query. This
-        # method should only be used if you need to filter or order based on columns in associated tables.
+        # method should only be used if you need to filter or order based on columns in associated tables,
+        # or if you have done comparative benchmarking and determined it is faster.
         #
         # This method uses <tt>Dataset#graph</tt> to create appropriate aliases for columns in all the
         # tables.  Then it uses the graph's metadata to build the associations from the single hash, and
@@ -2609,7 +3150,7 @@ END
         #
         # Be very careful when using this with multiple one_to_many or many_to_many associations, as you can
         # create large cartesian products.  If you must graph multiple one_to_many and many_to_many associations,
-        # make sure your filters are narrow if you have a large database.
+        # make sure your filters are narrow if the datasets are large.
         # 
         # Each association's order, if defined, is respected. +eager_graph+ probably
         # won't work correctly on a limited dataset, unless you are
@@ -2620,6 +3161,88 @@ END
         #
         # Like +eager+, you need to call +all+ on the dataset for the eager loading to work.  If you just
         # call +each+, it will yield plain hashes, each containing all columns from all the tables.
+        #
+        # To modify the associated dataset that will be joined to the current dataset, you should use a
+        # hash for the association, with the key being the association name symbol, and the value being
+        # a callable object that is called with the associated dataset and should return a modified
+        # dataset.  If that association also has dependent associations, instead of a callable object,
+        # use a hash with the callable object being the key, and the dependent association(s) as the value.
+        # 
+        # You can specify an custom alias and/or join type on a per-association basis by providing an
+        # Sequel::SQL::AliasedExpression object instead of an a Symbol for the association name.
+        #
+        # You cannot mix calls to +eager_graph+ and +graph+ on the same dataset.
+        #
+        # Examples:
+        #
+        #   # For each album, eager_graph load the artist
+        #   Album.eager_graph(:artist).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # LEFT OUTER JOIN artists AS artist ON (artists.id = albums.artist_id)
+        #
+        #   # For each album, eager_graph load the artist, using a specified alias
+        #   Album.eager_graph(Sequel[:artist].as(:a)).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # LEFT OUTER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
+        #   # For each album, eager_graph load the artist, using a specified alias
+        #   # and custom join type
+        #
+        #   Album.eager_graph(Sequel[:artist].as(:a, join_type: :inner)).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # INNER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
+        #   # For each album, eager_graph load the artist and genre
+        #   Album.eager_graph(:artist, :genre).all
+        #   Album.eager_graph(:artist).eager_graph(:genre).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)
+        #   # LEFT OUTER JOIN genres AS genre ON (genre.id = albums.genre_id)
+        #
+        #   # For each artist, eager_graph load albums and tracks for each album
+        #   Artist.eager_graph(albums: :tracks).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
+        #
+        #   # For each artist, eager_graph load albums, tracks for each album, and genre for each track
+        #   Artist.eager_graph(albums: {tracks: :genre}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
+        #   # LEFT OUTER JOIN genres AS genre ON (genre.id = tracks.genre_id)
+        #
+        #   # For each artist, eager_graph load albums with year > 1990
+        #   Artist.eager_graph(albums: proc{|ds| ds.where{year > 1990}}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #
+        #   # For each artist, eager_graph load albums and tracks 1-10 for each album
+        #   Artist.eager_graph(albums: {tracks: proc{|ds| ds.where(number: 1..10)}}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN (
+        #   #   SELECT * FROM tracks WHERE ((number >= 1) AND (number <= 10))
+        #   # ) AS tracks ON (tracks.albums_id = albums.id)
+        #
+        #   # For each artist, eager_graph load albums with year > 1990, and tracks for those albums
+        #   Artist.eager_graph(albums: {proc{|ds| ds.where{year > 1990}}=>:tracks}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
         def eager_graph(*associations)
           eager_graph_with_options(associations)
         end
@@ -2645,8 +3268,11 @@ END
         #                    significantly slower in some cases (perhaps even the majority of cases), so you should
         #                    only use this if you have benchmarked that it is faster for your use cases.
         def eager_graph_with_options(associations, opts=OPTS)
+          return self if associations.empty?
+
+          opts = opts.dup unless opts.frozen?
           associations = [associations] unless associations.is_a?(Array)
-          if eg = @opts[:eager_graph]
+          ds = if eg = @opts[:eager_graph]
             eg = eg.dup
             [:requirements, :reflections, :reciprocals, :limits].each{|k| eg[k] = eg[k].dup}
             eg[:local] = opts
@@ -2660,13 +3286,17 @@ END
             # :limits :: Any limit/offset array slicing that need to be handled in ruby land after loading
             opts = {:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :limits=>{}, :local=>opts, :cartesian_product_number=>0, :row_proc=>row_proc}
             ds = clone(:eager_graph=>opts)
-            ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
+            ds = ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
           end
+
+          ds.opts[:eager_graph].freeze
+          ds.opts[:eager_graph].each_value{|v| v.freeze if v.is_a?(Hash)}
+          ds
         end
 
         # If the dataset is being eagerly loaded, default to calling all
         # instead of each.
-        def to_hash(key_column=nil, value_column=nil, opts=OPTS)
+        def as_hash(key_column=nil, value_column=nil, opts=OPTS)
           if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
             opts = Hash[opts]
             opts[:all] = true
@@ -2691,7 +3321,7 @@ END
         def ungraphed
           ds = super.clone(:eager_graph=>nil)
           if (eg = @opts[:eager_graph]) && (rp = eg[:row_proc])
-            ds.row_proc = rp
+            ds = ds.with_row_proc(rp)
           end
           ds
         end
@@ -2709,11 +3339,16 @@ END
         # ta :: table_alias used for the parent association
         # requirements :: an array, used as a stack for requirements
         # r :: association reflection for the current association, or an SQL::AliasedExpression
-        #      with the reflection as the expression and the alias base as the aliaz.
+        #      with the reflection as the expression, the alias base as the alias (or nil to
+        #      use the default alias), and an optional hash with a :join_type entry as the columns
+        #      to use a custom join type.
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
           if r.is_a?(SQL::AliasedExpression)
             alias_base = r.alias
+            if r.columns.is_a?(Hash)
+              join_type = r.columns[:join_type]
+            end
             r = r.expression
           else
             alias_base = r[:graph_alias_base]
@@ -2731,9 +3366,14 @@ END
           end
           local_opts = ds.opts[:eager_graph][:local]
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
-          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
+
+          if r[:conditions] && !Sequel.condition_specifier?(r[:conditions]) && !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block)
+            raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
+          end
+
+          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>join_type || local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
           if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
-            ds = ds.order_more(*qualified_expression(order, assoc_table_alias))
+            ds = ds.order_append(*qualified_expression(order, assoc_table_alias))
           end
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup
@@ -2756,7 +3396,6 @@ END
         # requirements :: an array, used as a stack for requirements
         # *associations :: the associations to add to the graph
         def eager_graph_associations(ds, model, ta, requirements, *associations)
-          return ds if associations.empty?
           associations.flatten.each do |association|
             ds = case association
             when Symbol, SQL::AliasedExpression
@@ -2776,7 +3415,7 @@ END
         # Replace the array of plain hashes with an array of model objects will all eager_graphed
         # associations set in the associations cache for each object.
         def eager_graph_build_associations(hashes)
-          hashes.replace(EagerGraphLoader.new(self).load(hashes))
+          hashes.replace(_eager_graph_build_associations(hashes, eager_graph_loader))
         end
       
         private
@@ -2787,12 +3426,18 @@ END
           clone(:join=>clone(:graph_from_self=>false).eager_graph_with_options(associations, :join_type=>type, :join_only=>true).opts[:join])
         end
 
+        # Process the array of hashes using the eager graph loader to return an array
+        # of model objects with the associations set.
+        def _eager_graph_build_associations(hashes, egl)
+          egl.load(hashes)
+        end
+
         # If the association has conditions itself, then it requires additional filters be
         # added to the current dataset to ensure that the passed in object would also be
         # included by the association's conditions.
         def add_association_filter_conditions(ref, obj, expr)
           if expr != SQL::Constants::FALSE && ref.filter_by_associations_add_conditions?
-            Sequel.expr(ref.filter_by_associations_conditions_expression(obj))
+            Sequel[ref.filter_by_associations_conditions_expression(obj)]
           else
             expr
           end
@@ -2820,6 +3465,7 @@ END
         # Return an expression for filtering by the given association reflection and associated object.
         def association_filter_expression(op, ref, obj)
           meth = :"#{ref[:type]}_association_filter_expression"
+          # Allow calling private association specific method to get filter expression
           send(meth, op, ref, obj) if respond_to?(meth, true)
         end
 
@@ -2870,23 +3516,60 @@ END
         # Allow associations that are eagerly graphed to be specified as an SQL::AliasedExpression, for
         # per-call determining of the alias base.
         def eager_graph_check_association(model, association)
-          if association.is_a?(SQL::AliasedExpression)
-            SQL::AliasedExpression.new(check_association(model, association.expression), association.alias)
+          reflection = if association.is_a?(SQL::AliasedExpression)
+            expr = association.expression
+            if expr.is_a?(SQL::Identifier)
+              expr = expr.value
+              if expr.is_a?(String)
+                expr = expr.to_sym
+              end
+            end
+
+            check_reflection = check_association(model, expr)
+            SQL::AliasedExpression.new(check_reflection, association.alias || expr, association.columns)
           else
-            check_association(model, association)
+            check_reflection = check_association(model, association)
+          end
+
+          if check_reflection && check_reflection[:allow_eager_graph] == false
+            raise Error, "eager_graph not allowed for #{reflection.inspect}"
           end
+
+          reflection
         end
       
-        # Eagerly load all specified associations 
+        # The EagerGraphLoader instance used for converting eager_graph results.
+        def eager_graph_loader
+          unless egl = cache_get(:_model_eager_graph_loader)
+            egl = cache_set(:_model_eager_graph_loader, EagerGraphLoader.new(self))
+          end
+          egl.dup
+        end
+
+        # Eagerly load all specified associations.
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
-          # Key is foreign/primary key name symbol
+
+          # Reflections for all associations to eager load
+          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+
+          perform_eager_loads(prepare_eager_load(a, reflections, eager_assoc))
+
+          reflections.each do |r|
+            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
+          end 
+
+          nil
+        end
+
+        # Prepare a hash loaders and eager options which will be used to implement the eager loading.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          eager_load_data = {}
+
+          # Key is foreign/primary key name symbol.
           # Value is hash with keys being foreign/primary key values (generally integers)
-          #  and values being an array of current model objects with that
-          #  specific foreign/primary key
+          # and values being an array of current model objects with that specific foreign/primary key
           key_hash = {}
-          # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
           # Populate the key_hash entry for each association being eagerly loaded
           reflections.each do |r|
@@ -2917,17 +3600,30 @@ END
               id_map = nil
             end
           
-            loader = r[:eager_loader]
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
-              associations = {}
+              associations = OPTS
             elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
               eager_block, associations = pr_assoc
             end
-            loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map)
-            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} unless r[:after_load].empty?
-          end 
+
+            eager_load_data[r[:eager_loader]] = {:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map}
+          end
+
+          eager_load_data
+        end
+
+        # Using the hash of loaders and eager options, perform the eager loading.
+        def perform_eager_loads(eager_load_data)
+          eager_load_data.map do |loader, eo|
+            perform_eager_load(loader, eo)
+          end
+        end
+
+        # Perform eager loading for a single association using the loader and eager options.
+        def perform_eager_load(loader, eo)
+          loader.call(eo)
         end
 
         # Return a subquery expression for filering by a many_to_many association
@@ -2982,6 +3678,10 @@ END
         end
         alias one_to_one_association_filter_expression one_to_many_association_filter_expression
 
+        def non_sql_option?(key)
+          super || key == :eager || key == :eager_graph
+        end
+
         # Build associations from the graph if #eager_graph was used, 
         # and/or load other associations if #eager was used.
         def post_load(all_records)
@@ -3011,7 +3711,6 @@ END
         # Hash with table alias symbol keys and [limit, offset] values
         attr_reader :limit_map
         
-        # Hash with table alias symbol keys and callable values used to create model instances
         # The table alias symbol for the primary model
         attr_reader :master
         
@@ -3054,19 +3753,22 @@ END
           after_load_map = @after_load_map = {}
           reflection_map.each do |k, v|
             alias_map[k] = v[:name]
-            after_load_map[k] = v[:after_load] unless v[:after_load].empty?
+            after_load_map[k] = v[:after_load] if v[:after_load]
             type_map[k] = if v.returns_array?
               true
             elsif (limit_and_offset = limit_map[k]) && !limit_and_offset.last.nil?
               :offset
             end
           end
+          after_load_map.freeze
+          alias_map.freeze
+          type_map.freeze
 
           # Make dependency map hash out of requirements array for each association.
           # This builds a tree of dependencies that will be used for recursion
           # to ensure that all parts of the object graph are loaded into the
           # appropriate subordinate association.
-          @dependency_map = {}
+          dependency_map = @dependency_map = {}
           # Sort the associations by requirements length, so that
           # requirements are added to the dependency hash before their
           # dependencies.
@@ -3082,20 +3784,14 @@ END
               hash[ta] = {}
             end
           end
+          freezer = lambda do |h|
+            h.freeze
+            h.each_value(&freezer)
+          end
+          freezer.call(dependency_map)
       
-          # This mapping is used to make sure that duplicate entries in the
-          # result set are mapped to a single record.  For example, using a
-          # single one_to_many association with 10 associated records,
-          # the main object column values appear in the object graph 10 times.
-          # We map by primary key, if available, or by the object's entire values,
-          # if not. The mapping must be per table, so create sub maps for each table
-          # alias.
-          records_map = {@master=>{}}
-          alias_map.keys.each{|ta| records_map[ta] = {}}
-          @records_map = records_map
-
           datasets = opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
-          column_aliases = opts[:graph_aliases] || opts[:graph][:column_aliases]
+          column_aliases = opts[:graph][:column_aliases]
           primary_keys = {}
           column_maps = {}
           models = {}
@@ -3119,9 +3815,9 @@ END
               h.select{|ca, c| primary_keys[ta] = ca if pk == c}
             end
           end
-          @column_maps = column_maps
-          @primary_keys = primary_keys
-          @row_procs = row_procs
+          @column_maps = column_maps.freeze
+          @primary_keys = primary_keys.freeze
+          @row_procs = row_procs.freeze
 
           # For performance, create two special maps for the master table,
           # so you can skip a hash lookup.
@@ -3133,22 +3829,35 @@ END
           # used for performance, to get all values in one hash lookup instead of
           # separate hash lookups for each data structure.
           ta_map = {}
-          alias_map.keys.each do |ta|
-            ta_map[ta] = [records_map[ta], row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]]
+          alias_map.each_key do |ta|
+            ta_map[ta] = [row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]].freeze
           end
-          @ta_map = ta_map
+          @ta_map = ta_map.freeze
+          freeze
         end
 
         # Return an array of primary model instances with the associations cache prepopulated
         # for all model objects (both primary and associated).
         def load(hashes)
+          # This mapping is used to make sure that duplicate entries in the
+          # result set are mapped to a single record.  For example, using a
+          # single one_to_many association with 10 associated records,
+          # the main object column values appear in the object graph 10 times.
+          # We map by primary key, if available, or by the object's entire values,
+          # if not. The mapping must be per table, so create sub maps for each table
+          # alias.
+          @records_map = records_map = {}
+          alias_map.keys.each{|ta| records_map[ta] = {}}
+
           master = master()
       
           # Assign to local variables for speed increase
           rp = row_procs[master]
-          rm = records_map[master]
+          rm = records_map[master] = {}
           dm = dependency_map
 
+          records_map.freeze
+
           # This will hold the final record set that we will be replacing the object graph with.
           records = []
 
@@ -3169,6 +3878,9 @@ END
           # Run after_load procs if there are any
           post_process(records, dm) if @unique || !after_load_map.empty? || !limit_map.empty?
 
+          records_map.each_value(&:freeze)
+          freeze
+
           records
         end
       
@@ -3188,7 +3900,17 @@ END
               end
               key = hkey(ta_h)
             end
-            rm, rp, assoc_name, tm, rcm = @ta_map[ta]
+            rp, assoc_name, tm, rcm = @ta_map[ta]
+            rm = records_map[ta]
+
+            # Check type map for all dependencies, and use a unique
+            # object if any are dependencies for multiple objects,
+            # to prevent duplicate objects from showing up in the case
+            # the normal duplicate removal code is not being used.
+            if !@unique && !deps.empty? && deps.any?{|dep_key,_| @ta_map[dep_key][2]}
+              key = [current.object_id, key]
+            end
+
             unless rec = rm[key]
               rec = rm[key] = rp.call(hfor(ta, h))
             end
@@ -3217,7 +3939,7 @@ END
         # Return a suitable hash key for any subhash +h+, which is an array of values by column order.
         # This is only used if the primary key cannot be used.
         def hkey(h)
-          h.sort_by{|x| x[0].to_s}
+          h.sort_by{|x| x[0]}
         end
 
         # Return the subhash for the master table by parsing the values out of the main hash +h+
@@ -3262,7 +3984,7 @@ END
           records.each do |record|
             dependency_map.each do |ta, deps|
               assoc_name = alias_map[ta]
-              list = record.send(assoc_name)
+              list = record.public_send(assoc_name)
               rec_list = if type_map[ta]
                 list.uniq!
                 if lo = limit_map[ta]