sequel 5.33.0 → 5.58.0

data/lib/sequel/model/associations.rb

@@ -164,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
@@ -263,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?
@@ -272,7 +274,9 @@ 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
@@ -311,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
@@ -356,7 +361,7 @@ module Sequel
         def finalize
           return unless cache = self[:cache]
 
-          finalize_settings.each do |meth, key|
+          finalizer = proc do |meth, key|
             next if has_key?(key)
 
             # Allow calling private methods to make sure caching is done appropriately
@@ -364,6 +369,13 @@ module Sequel
             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
 
@@ -371,9 +383,7 @@ module Sequel
         FINALIZE_SETTINGS = {
           :associated_class=>:class,
           :associated_dataset=>:_dataset,
-          :associated_eager_dataset=>:associated_eager_dataset,
           :eager_limit_strategy=>:_eager_limit_strategy,
-          :filter_by_associations_conditions_dataset=>:filter_by_associations_conditions_dataset,
           :placeholder_loader=>:placeholder_loader,
           :predicate_key=>:predicate_key,
           :predicate_keys=>:predicate_keys,
@@ -432,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(Sequel.&(*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
@@ -626,9 +640,7 @@ 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
@@ -655,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}
@@ -796,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
     
@@ -1244,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
@@ -1304,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
@@ -1361,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
@@ -1581,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
@@ -1591,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
@@ -1609,6 +1655,7 @@ module Sequel
         #                     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.
@@ -1663,7 +1710,7 @@ 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.
@@ -1675,6 +1722,10 @@ module Sequel
         #           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
@@ -1687,6 +1738,7 @@ module Sequel
         #                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
@@ -1695,6 +1747,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.
@@ -1751,6 +1804,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.
@@ -1780,7 +1836,9 @@ 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 = Hash[default_association_options]
@@ -1791,11 +1849,12 @@ module Sequel
           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
           opts = assoc_class.new.merge!(opts)
 
@@ -1803,6 +1862,7 @@ 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)
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
@@ -1825,8 +1885,7 @@ module Sequel
           # 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]
@@ -1899,6 +1958,12 @@ module Sequel
         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.
@@ -1910,7 +1975,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).send(: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.
@@ -1919,6 +1999,13 @@ 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) do |dynamic_opts=OPTS, &block|
@@ -1944,15 +2031,13 @@ module Sequel
             opts[:setter_method] = :"#{opts[:name]}="
           end
 
-          association_module_def(opts.dataset_method, opts){_dataset(opts)}
+          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
-          if opts[:dataset]
-            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])
-          end
-          def_association_method(opts)
+          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]
 
@@ -1964,17 +2049,17 @@ module Sequel
 
           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_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_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_delegate_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
           end
         end
         
@@ -1996,7 +2081,7 @@ 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
@@ -2005,8 +2090,75 @@ module Sequel
             opts[:after_load] ||= []
             opts[:after_load].unshift(:array_uniq!)
           end
-          opts[:dataset] ||= opts.association_dataset_proc
-          opts[:eager_loader] ||= opts.method(:default_eager_loader)
+          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]
@@ -2040,50 +2192,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)
+            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)
 
-              checked_transaction do
-                current = jtds.first
+                checked_transaction do
+                  current = jtds.first
 
-                if o
-                  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)
+                    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
@@ -2122,9 +2284,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
       
@@ -2142,8 +2302,12 @@ module Sequel
       
           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
@@ -2171,7 +2335,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]
@@ -2210,49 +2374,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)})))
+            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)}
+                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
-                save_old = true
-              end
 
-              if o
-                if !o.new? && !save_old
-                  up_ds = up_ds.exclude(o.pk_hash)
+                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
-                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
+                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
+                  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
@@ -2346,7 +2520,7 @@ module Sequel
 
         # 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
 
@@ -2367,7 +2541,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
 
@@ -2408,6 +2587,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)
@@ -2550,6 +2732,9 @@ module Sequel
           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)
@@ -2571,6 +2756,9 @@ module Sequel
           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
@@ -2819,6 +3007,8 @@ module Sequel
               (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
@@ -2940,7 +3130,7 @@ module Sequel
 
         # 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,
-        # or if you have done comparative benchmarking it and determined it is faster.
+        # 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
@@ -2969,6 +3159,8 @@ module Sequel
         # 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
@@ -3064,6 +3256,8 @@ module Sequel
         #                    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)
           ds = if eg = @opts[:eager_graph]
@@ -3190,7 +3384,6 @@ module Sequel
         # 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
@@ -3311,7 +3504,7 @@ module Sequel
         # 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)
+          reflection = if association.is_a?(SQL::AliasedExpression)
             expr = association.expression
             if expr.is_a?(SQL::Identifier)
               expr = expr.value
@@ -3320,10 +3513,17 @@ module Sequel
               end
             end
 
-            SQL::AliasedExpression.new(check_association(model, expr), association.alias || expr, association.columns)
+            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
       
         # The EagerGraphLoader instance used for converting eager_graph results.
@@ -3334,15 +3534,30 @@ module Sequel
           egl.dup
         end
 
-        # Eagerly load all specified associations 
+        # Eagerly load all specified associations.
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
+
+          # 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
           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}")}
       
           # Populate the key_hash entry for each association being eagerly loaded
           reflections.each do |r|
@@ -3373,7 +3588,6 @@ module Sequel
               id_map = nil
             end
           
-            loader = r[:eager_loader]
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
@@ -3381,9 +3595,23 @@ module Sequel
             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]])} if r[:after_load]
-          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