sequel 5.39.0 → 5.72.0

data/lib/sequel/model/associations.rb

@@ -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 || !use_placeholder_loader?
             ds = eager_loading_dataset(eo)
 
             strategy = ds.opts[:eager_limit_strategy] || strategy
@@ -295,13 +299,28 @@ module Sequel
             strategy = :ruby if strategy == :correlated_subquery
             strategy = nil if strategy == :ruby && assign_singular?
             objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
+
+            if strategy == :window_function
+              delete_rn = ds.row_number_column 
+              objects.each{|obj| obj.values.delete(delete_rn)}
+            end
           elsif strategy == :union
             objects = []
             ds = associated_dataset
             loader = union_eager_loader
             joiner = " UNION ALL "
             ids.each_slice(subqueries_per_union).each do |slice|
-              objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
+              sql = loader.send(:sql_origin)
+              join = false
+              slice.each do |k|
+                if join
+                  sql << joiner
+                else
+                  join = true
+                end
+                loader.append_sql(sql, *k)
+              end
+              objects.concat(ds.with_sql(sql).to_a)
             end
             ds = ds.eager(cascade) if cascade
             ds.send(:post_load, objects)
@@ -311,7 +330,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
@@ -436,7 +456,7 @@ module Sequel
         def placeholder_loader
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
-              Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+              associated_dataset.placeholder_literalizer_loader do |pl, ds|
                 ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
                 if self[:block]
                   ds = self[:block].call(ds)
@@ -635,9 +655,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
@@ -664,6 +682,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}
@@ -731,8 +758,8 @@ module Sequel
         # A placeholder literalizer used to speed up eager loading.
         def placeholder_eager_loader
           cached_fetch(:placeholder_eager_loader) do
-            Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-              apply_eager_limit_strategy(eager_loading_dataset.where(predicate_key=>pl.arg), eager_limit_strategy)
+            eager_loading_dataset.placeholder_literalizer_loader do |pl, ds|
+              apply_eager_limit_strategy(ds.where(predicate_key=>pl.arg), eager_limit_strategy)
             end
           end
         end
@@ -791,7 +818,7 @@ module Sequel
         # loading a limited association.
         def union_eager_loader
           cached_fetch(:union_eager_loader) do
-            Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+            associated_dataset.placeholder_literalizer_loader do |pl, ds|
               ds = self[:eager_block].call(ds) if self[:eager_block]
               keys = predicate_keys
               ds = ds.where(keys.map{pl.arg}.zip(keys))
@@ -805,7 +832,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          self[:use_placeholder_loader]
+          self[:use_placeholder_loader] && _associated_dataset.supports_placeholder_literalizer?
         end
       end
     
@@ -1315,7 +1342,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
@@ -1372,10 +1399,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
@@ -1592,6 +1639,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
@@ -1602,6 +1650,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
@@ -1620,6 +1670,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.
@@ -1674,18 +1725,26 @@ 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.
+        # :graph_use_association_block :: Makes eager_graph consider the association block. Without this, eager_graph
+        #                                 ignores the bock and only use the :graph_* options.
+        # :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
@@ -1698,6 +1757,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
@@ -1706,6 +1766,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.
@@ -1762,6 +1823,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.
@@ -1791,7 +1855,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]
@@ -1809,6 +1875,16 @@ module Sequel
             # in certain places to disable optimizations.
             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)
 
           if opts[:clone] && !opts.cloneable?(cloned_assoc)
@@ -1838,8 +1914,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]
@@ -1929,7 +2004,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.
@@ -1938,6 +2028,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|
@@ -1963,13 +2060,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
           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)
+          def_association_method(opts) unless opts[:no_association_method]
 
           return if opts[:read_only]
 
@@ -1981,17 +2078,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
         
@@ -2013,7 +2110,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
@@ -2022,8 +2119,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]
@@ -2057,50 +2221,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
-
-                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
@@ -2157,8 +2331,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
@@ -2225,49 +2403,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
@@ -2285,6 +2473,9 @@ module Sequel
         # Return dataset to graph into given the association reflection, applying the :callback option if set.
         def eager_graph_dataset(opts, eager_options)
           ds = opts.associated_class.dataset
+          if opts[:graph_use_association_block] && (b = opts[:block])
+            ds = b.call(ds)
+          end
           if cb = eager_options[:callback]
             ds = cb.call(ds)
           end
@@ -2361,7 +2552,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
 
@@ -2382,7 +2573,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
 
@@ -2423,6 +2619,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)
@@ -2565,6 +2764,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)
@@ -2586,6 +2788,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
@@ -2834,6 +3039,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
@@ -2955,7 +3162,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
@@ -2984,6 +3191,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
@@ -3327,7 +3536,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
@@ -3336,10 +3545,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.
@@ -3350,15 +3566,30 @@ module Sequel
           egl.dup
         end
 
-        # Eagerly load all specified associations 
-        def eager_load(a, eager_assoc=@opts[:eager])
+        # Eagerly load all specified associations.
+        def eager_load(a, eager_assoc=@opts[:eager], m=model)
           return if a.empty?
+
+          # Reflections for all associations to eager load
+          reflections = eager_assoc.keys.map{|assoc| m.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|
@@ -3389,7 +3620,6 @@ module Sequel
               id_map = nil
             end
           
-            loader = r[:eager_loader]
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
@@ -3397,9 +3627,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