sequel 4.49.0 → 5.3.0

data/lib/sequel/model/associations.rb

@@ -10,10 +10,11 @@ module Sequel
 
       # 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
@@ -33,27 +34,27 @@ module Sequel
 
         # 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.
@@ -81,9 +82,10 @@ module Sequel
 
         # Apply all non-instance specific changes to the given dataset and return it.
         def apply_dataset_changes(ds)
-          ds = ds.with_extend(AssociationDatasetMethods).
-            clone(:association_reflection => self)
-          self[:extend].each{|m| ds = ds.with_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)
@@ -143,6 +145,7 @@ module Sequel
           rn = ds.row_number_column 
           limit, offset = limit_and_offset
           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
@@ -191,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.
@@ -325,12 +328,6 @@ module Sequel
           false
         end
 
-        # Alias of predicate_key, only for backwards compatibility.
-        def eager_loading_predicate_key
-          Sequel::Deprecation.deprecate("AssociationReflection#eager_loading_predicate_key", "Use #predicate_key instead")
-          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.
@@ -362,6 +359,7 @@ module Sequel
           finalize_settings.each 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
@@ -401,7 +399,7 @@ module Sequel
           end
         end
 
-        # Show which type of reflection this is, and a guess at what line was used to create the
+        # 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
@@ -450,9 +448,7 @@ 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
@@ -505,7 +501,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
@@ -516,7 +512,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.
@@ -543,7 +539,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.
@@ -556,8 +552,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]
@@ -567,7 +565,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}
@@ -576,10 +574,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
@@ -1106,7 +1104,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
@@ -1451,8 +1449,6 @@ module Sequel
     
       # This module contains methods added to all association datasets
       module AssociationDatasetMethods
-        Dataset.def_deprecated_opts_setter(self, :model_object, :association_reflection)
-
         # The model object that created the association dataset
         def model_object
           @opts[:model_object]
@@ -1508,7 +1504,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
@@ -1530,7 +1526,7 @@ 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
 
@@ -1605,7 +1601,7 @@ 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).
         # :clone :: Merge the current options and block into the options and block used in defining
@@ -1678,8 +1674,7 @@ module Sequel
         # :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
@@ -1710,7 +1705,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.
@@ -1803,10 +1798,6 @@ module Sequel
           end
 
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
-          if !opts.has_key?(:predicate_key) && opts.has_key?(:eager_loading_predicate_key)
-            Sequel::Deprecation.deprecate("The :eager_loading_predicate_key association option", "Use the :predicate_key option instead")
-            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]
@@ -1814,9 +1805,15 @@ 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
@@ -1877,7 +1874,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
@@ -1887,7 +1884,7 @@ 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
@@ -1918,14 +1915,29 @@ module Sequel
 
         # Adds the association method to the association methods module.
         def def_association_method(opts)
-          association_module_def(opts.association_method, opts) do |*dynamic_opts, &block|
-            Sequel::Deprecation.deprecate("Passing multiple arguments to ##{opts.association_method}", "Additional arguments are currently ignored") if dynamic_opts.length > 1
-            load_associated_objects(opts, dynamic_opts.length == 0 ? 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)
+          # 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)}
           def_association_method(opts)
 
@@ -1933,23 +1945,23 @@ module Sequel
 
           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_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_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_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
           end
         end
         
@@ -1976,7 +1988,10 @@ module Sequel
           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]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= opts.association_dataset_proc
           opts[:eager_loader] ||= opts.method(:default_eager_loader)
           
@@ -2273,7 +2288,7 @@ module Sequel
 
         # 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
@@ -2353,7 +2368,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
@@ -2407,28 +2423,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
-            Sequel::Deprecation.deprecate("Passing #{dynamic_opts.inspect} an argument to an association loading method", "Pass {:reload=>#{dynamic_opts.inspect}} instead")
-            {:reload=>dynamic_opts}
-          when Hash
-            Hash[dynamic_opts]
-          else
-            if dynamic_opts.respond_to?(:call)
-              Sequel::Deprecation.deprecate("Passing callbable argument #{dynamic_opts.inspect} to an association loading method", "Pass a block to the method to use a callback")
-              {:callback=>dynamic_opts}
-            else
-              Sequel::Deprecation.deprecate("Passing #{dynamic_opts.inspect} an argument to an association loading method", "Pass {:reload=>true} if you would like to reload the association")
-              {:reload=>true}
-            end
-          end
-
-          if block_given?
+          if block
+            dynamic_opts = Hash[dynamic_opts]
             dynamic_opts[:callback] = block
           end
 
@@ -2436,7 +2434,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]
@@ -2490,7 +2488,8 @@ 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
@@ -2503,13 +2502,14 @@ 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)
@@ -2522,7 +2522,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
 
@@ -2540,30 +2540,28 @@ 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
-              Sequel::Deprecation.deprecate("Having #{callback_type} association callback return false to cancel modification", "Instead, call Model#cancel_action inside the association callback")
-              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
@@ -2572,7 +2570,8 @@ module Sequel
           return if a && a == o && !set_associated_object_if_same?
           run_association_callbacks(opts, :before_set, o)
           remove_reciprocal_object(opts, a) if a
-          send(opts._setter_method, o)
+          # Allow calling private _setter method
+          send(opts[:_setter_method], o)
           associations[opts[:name]] = o
           add_reciprocal_object(opts, o) if o
           run_association_callbacks(opts, :after_set, o)
@@ -2630,37 +2629,35 @@ module Sequel
       #   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
+      #   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
@@ -2741,7 +2738,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
@@ -2758,7 +2755,8 @@ END
         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 it 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
@@ -2766,7 +2764,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
@@ -2890,7 +2888,7 @@ END
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
 
           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)
-            Sequel::Deprecation.deprecate("Ignoring :conditions for #{r[:model]} #{r[:name]} association during eager_graph/association_join, consider specifying :graph_block") unless r[:ignore_conditions_warning]
+            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=>local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
@@ -2982,6 +2980,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
 
@@ -3042,10 +3041,9 @@ 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
+          # 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.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
@@ -3088,7 +3086,7 @@ END
               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?
+            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
           end 
         end
 
@@ -3220,7 +3218,7 @@ 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?
@@ -3261,7 +3259,7 @@ END
           @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] # SEQUEL5: Remove :graph_aliases support
+          column_aliases = opts[:graph][:column_aliases]
           primary_keys = {}
           column_maps = {}
           models = {}
@@ -3383,7 +3381,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+
@@ -3428,7 +3426,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]