sequel 3.21.0 → 3.41.0

data/lib/sequel/plugins/identity_map.rb

@@ -22,10 +22,7 @@ module Sequel
     # Identity maps are thread-local and only persist for the duration of the block,
     # so they should only be considered as a possible performance enhancer.
     #
-    # The identity_map plugin is not compatible with the standard eager loading of
-    # many_to_many and many_through_many associations.  If you want to use the identity_map plugin,
-    # you should use +eager_graph+ instead of +eager+ for those associations. It is also
-    # not compatible with the eager loading in the +rcte_tree+ plugin.
+    # The identity_map plugin is not compatible with the eager loading in the +rcte_tree+ plugin.
     #
     # Usage:
     #
@@ -37,6 +34,116 @@ module Sequel
     #   # would need to do Album.with_identity_map{} to use the identity map
     module IdentityMap
       module ClassMethods
+        # Override the default :eager_loader option for many_*_many associations to work
+        # with an identity_map.  If the :eager_graph association option is used, you'll probably have to use
+        # :uniq=>true on the current association amd :cartesian_product_number=>2 on the association
+        # mentioned by :eager_graph, otherwise you'll end up with duplicates because the row proc will be
+        # getting called multiple times for the same object.  If you do have duplicates and you use :eager_graph,
+        # they'll probably be lost.  Making that work correctly would require changing a lot of the core
+        # architecture, such as how graphing and eager graphing work.
+        def associate(type, name, opts = {}, &block)
+          if opts[:eager_loader]
+            super
+          elsif type == :many_to_many
+            opts = super
+            el = opts[:eager_loader] 
+            model = self
+            left_pk = opts[:left_primary_key]
+            uses_lcks = opts[:uses_left_composite_keys]
+            uses_rcks = opts[:uses_right_composite_keys]
+            right = opts[:right_key]
+            join_table = opts[:join_table]
+            left = opts[:left_key]
+            lcks = opts[:left_keys]
+            left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
+            opts[:eager_loader] = lambda do |eo|
+              return el.call(eo) unless model.identity_map
+              h = eo[:id_map]
+              eo[:rows].each{|object| object.associations[name] = []}
+              r = uses_rcks ? rcks.zip(opts.right_primary_keys) : [[right, opts.right_primary_key]]
+              l = uses_lcks ? [[lcks.map{|k| SQL::QualifiedIdentifier.new(join_table, k)}, h.keys]] : [[left, h.keys]]
+
+              # Replace the row proc to remove the left key alias before calling the previous row proc.
+              # Associate the value of the left key alias with the associated object (through its object_id).
+              # When loading the associated objects, lookup the left key alias value and associate the
+              # associated objects to the main objects if the left key alias value matches the left primary key
+              # value of the main object.
+              # 
+              # The deleting of the left key alias from the hash before calling the previous row proc
+              # is necessary when an identity map is used, otherwise if the same associated object is returned more than
+              # once for the association, it won't know which of current objects to associate it to.
+              ds = opts.associated_class.inner_join(join_table, r + l)
+              pr = ds.row_proc
+              h2 = {}
+              ds.row_proc = proc do |hash|
+                hash_key = if uses_lcks
+                  left_key_alias.map{|k| hash.delete(k)}
+                else
+                  hash.delete(left_key_alias)
+                end
+                obj = pr.call(hash)
+                (h2[obj.object_id] ||= []) << hash_key
+                obj
+              end
+              model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo) .all do |assoc_record|
+                if hash_keys = h2.delete(assoc_record.object_id)
+                  hash_keys.each do |hash_key|
+                    if objects = h[hash_key]
+                      objects.each{|object| object.associations[name].push(assoc_record)}
+                    end
+                  end
+                end
+              end
+            end
+            opts
+          elsif type == :many_through_many
+            opts = super
+            el = opts[:eager_loader] 
+            model = self
+            left_pk = opts[:left_primary_key]
+            left_key = opts[:left_key]
+            uses_lcks = opts[:uses_left_composite_keys]
+            left_keys = Array(left_key)
+            left_key_alias = opts[:left_key_alias]
+            opts[:eager_loader] = lambda do |eo|
+              return el.call(eo) unless model.identity_map
+              h = eo[:id_map]
+              eo[:rows].each{|object| object.associations[name] = []}
+              ds = opts.associated_class 
+              opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+              ft = opts.final_reverse_edge
+              conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
+
+              # See above comment in many_to_many eager_loader
+              ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
+              pr = ds.row_proc
+              h2 = {}
+              ds.row_proc = proc do |hash|
+                hash_key = if uses_lcks
+                  left_key_alias.map{|k| hash.delete(k)}
+                else
+                  hash.delete(left_key_alias)
+                end
+                obj = pr.call(hash)
+                (h2[obj.object_id] ||= []) << hash_key
+                obj
+              end
+              model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
+                if hash_keys = h2.delete(assoc_record.object_id)
+                  hash_keys.each do |hash_key|
+                    if objects = h[hash_key]
+                      objects.each{|object| object.associations[name].push(assoc_record)}
+                    end
+                  end
+                end
+              end
+            end
+            opts
+          else
+            super
+          end
+        end
+          
         # Returns the current thread-local identity map.  Should be a hash if
         # there is an active identity map, and nil otherwise.
         def identity_map
@@ -46,7 +153,8 @@ module Sequel
         # The identity map key for an object of the current class with the given pk.
         # May not always be correct for a class which uses STI.
         def identity_map_key(pk)
-          "#{self}:#{pk ? Array(pk).join(',') : "nil:#{rand}"}"
+          pk = Array(pk)
+          "#{self}:#{pk.join(',')}" unless pk.compact.empty?
         end
 
         # If the identity map is in use, check it for a current copy of the object.
@@ -56,13 +164,15 @@ module Sequel
         # certain fields in an initial query, make modifications to some of those
         # fields and request other, potentially overlapping fields in a new query,
         # and not have the second query override fields you modified.
-        def load(row)
-          return super unless idm = identity_map
-          if o = idm[identity_map_key(Array(primary_key).map{|x| row[x]})]
+        def call(row)
+          return super unless (idm = identity_map) && (pk = primary_key)
+          if (k = identity_map_key(Array(pk).map{|x| row[x]})) && (o = idm[k])
             o.merge_db_update(row)
           else
             o = super
-            idm[identity_map_key(o.pk)] = o
+            if (k = identity_map_key(o.pk))
+              idm[k] = o
+            end
           end
           o
         end
@@ -89,7 +199,7 @@ module Sequel
         # Check the current identity map if it exists for the object with
         # the matching pk.  If one is found, return it, otherwise call super.
         def primary_key_lookup(pk)
-          (idm = identity_map and o = idm[identity_map_key(pk)]) ? o : super
+          ((idm = identity_map) && (k = identity_map_key(pk)) && (o = idm[k])) ? o : super
         end
       end
 
@@ -97,8 +207,8 @@ module Sequel
         # Remove instances from the identity map cache if they are deleted.
         def delete
           super
-          if idm = model.identity_map
-            idm.delete(model.identity_map_key(pk))
+          if (idm = model.identity_map) && (k = model.identity_map_key(pk))
+            idm.delete(k)
           end
           self
         end
@@ -121,10 +231,19 @@ module Sequel
         # key option has a value and the association uses the primary key of
         # the associated class as the :primary_key option, check the identity
         # map for the associated object and return it if present.
-        def _load_associated_objects(opts)
+        def _load_associated_object(opts, dynamic_opts)
           klass = opts.associated_class
-          if klass.respond_to?(:identity_map) && idm = klass.identity_map and opts[:type] == :many_to_one and opts[:primary_key] == klass.primary_key and
-           opts[:key] and pk = _associated_object_pk(opts[:key]) and o = idm[klass.identity_map_key(pk)]
+          cache_lookup = opts.fetch(:idm_cache_lookup) do 
+            opts[:idm_cache_lookup] = klass.respond_to?(:identity_map) &&
+              opts[:type] == :many_to_one &&
+              opts[:key] &&
+              opts.primary_key == klass.primary_key
+          end
+          if cache_lookup &&
+            !dynamic_opts[:callback] &&
+            (idm = klass.identity_map) &&
+            (k = klass.identity_map_key(_associated_object_pk(opts[:key]))) && 
+            (o = idm[k])
             o
           else
             super

data/lib/sequel/plugins/instance_filters.rb

@@ -68,6 +68,16 @@ module Sequel
       
         private
         
+        # If there are any instance filters, make sure not to use the
+        # instance delete optimization.
+        def _delete_without_checking
+          if @instance_filters && !@instance_filters.empty?
+            _delete_dataset.delete 
+          else
+            super
+          end
+        end
+
         # Lazily initialize the instance filter array.
         def instance_filters
           @instance_filters ||= []

data/lib/sequel/plugins/instance_hooks.rb

@@ -29,7 +29,7 @@ module Sequel
         BEFORE_HOOKS = Sequel::Model::BEFORE_HOOKS
         AFTER_HOOKS = Sequel::Model::AFTER_HOOKS - [:after_initialize]
         HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-        HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block) end", __FILE__, __LINE__)}
+        HOOKS.each{|h| class_eval("def #{h}_hook(&block); add_instance_hook(:#{h}, &block); self end", __FILE__, __LINE__)}
         
         BEFORE_HOOKS.each{|h| class_eval("def #{h}; run_before_instance_hooks(:#{h}) == false ? false : super end", __FILE__, __LINE__)}
         AFTER_HOOKS.each{|h| class_eval(<<-END, __FILE__, __LINE__ + 1)}

data/lib/sequel/plugins/json_serializer.rb

@@ -56,6 +56,30 @@ module Sequel
     #   Album.to_json
     #   Album.filter(:artist_id=>1).to_json(:include=>:tags)
     #
+    # If you have an existing array of model instances you want to convert to
+    # JSON, you can call the class to_json method with the :array option:
+    #
+    #   Album.to_json(:array=>[Album[1], Album[2]])
+    #
+    # Note that active_support/json makes incompatible changes to the to_json API,
+    # and breaks some aspects of the json_serializer plugin.  You can undo the damage
+    # done by active_support/json by doing:
+    #
+    #   class Array
+    #     def to_json(options = {})
+    #       JSON.generate(self)
+    #     end
+    #   end
+    #
+    #   class Hash
+    #     def to_json(options = {})
+    #       JSON.generate(self)
+    #     end
+    #   end
+    #
+    # Note that this will probably cause active_support/json to no longer work
+    # correctly in some cases.
+    #
     # Usage:
     #
     #   # Add JSON output capability to all model subclass instances (called before loading subclasses)
@@ -134,8 +158,13 @@ module Sequel
       module InstanceMethods
         # Parse the provided JSON, which should return a hash,
         # and call +set+ with that hash.
-        def from_json(json)
-          set(JSON.parse(json))
+        def from_json(json, opts={})
+          h = JSON.parse(json)
+          if fields = opts[:fields]
+            set_fields(h, fields, opts)
+          else
+            set(h)
+          end
         end
 
         # Return a string in JSON format.  Accepts the following
@@ -149,7 +178,7 @@ module Sequel
         #             to include in the JSON output.  Using a nested
         #             hash, you can pass options to associations
         #             to affect the JSON used for associated objects.
-        # :naked :: Not to add the JSON.create_id key to the JSON
+        # :naked :: Not to add the JSON.create_id (json_class) key to the JSON
         #           output hash, so when the JSON is parsed, it
         #           will yield a hash instead of a model object.
         # :only :: Symbol or Array of Symbols of columns to only
@@ -195,7 +224,21 @@ module Sequel
       module DatasetMethods
         # Return a JSON string representing an array of all objects in
         # this dataset.  Takes the same options as the the instance
-        # method, and passes them to every instance.
+        # method, and passes them to every instance.  Additionally,
+        # respects the following options:
+        #
+        # :array :: An array of instances.  If this is not provided,
+        #           calls #all on the receiver to get the array.
+        # :root :: If set to :collection, only wraps the collection
+        #          in a root object.  If set to :instance, only wraps
+        #          the instances in a root object.  If set to :both,
+        #          wraps both the collection and instances in a root
+        #          object.  Unfortunately, for backwards compatibility,
+        #          if this option is true and doesn't match one of those
+        #          symbols, it defaults to both.  That may change in a
+        #          future version, so for forwards compatibility, you
+        #          should pick a specific symbol for your desired
+        #          behavior.
         def to_json(*a)
           if opts = a.first.is_a?(Hash)
             opts = model.json_serializer_opts.merge(a.first)
@@ -203,8 +246,36 @@ module Sequel
           else
             opts = model.json_serializer_opts
           end
-          res = row_proc ? all.map{|obj| Literal.new(obj.to_json(opts))} : all
-          opts[:root] ? {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a) : res.to_json(*a)
+
+          collection_root = case opts[:root]
+          when nil, false, :instance
+            false
+          when :collection
+            opts = opts.dup
+            opts.delete(:root)
+            opts[:naked] = true unless opts.has_key?(:naked)
+            true
+          else
+            true
+          end
+
+          res = if row_proc 
+            array = if opts[:array]
+              opts = opts.dup
+              opts.delete(:array)
+            else
+              all
+            end
+            array.map{|obj| Literal.new(obj.to_json(opts))}
+           else
+            all
+          end
+
+          if collection_root
+            {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a)
+          else
+            res.to_json(*a)
+          end
         end
       end
     end

data/lib/sequel/plugins/list.rb

@@ -39,9 +39,11 @@ module Sequel
     #   Item.plugin :list, :scope=>:user_id
     # 
     # Note that using this plugin modifies the order of the model's dataset to
-    # sort by the position and scope fields.
+    # sort by the position and scope fields.  Also note that this plugin is subject to
+    # race conditions, and is not safe when concurrent modifications are made
+    # to the same list.
     #
-    # Also note that unlike ruby arrays, the list plugin assumes that the
+    # Additionally, note that unlike ruby arrays, the list plugin assumes that the
     # first entry in the list has position 1, not position 0.
     #
     # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
@@ -90,6 +92,15 @@ module Sequel
           list_dataset.first(position_field => p)
         end
 
+        # Set the value of the position_field to the maximum value plus 1 unless the
+        # position field already has a value.
+        def before_create
+          unless send(position_field)
+            send("#{position_field}=", list_dataset.max(position_field).to_i+1)
+          end
+          super
+        end
+
         # Find the last position in the list containing this instance.
         def last_position
           list_dataset.max(position_field).to_i

data/lib/sequel/plugins/many_through_many.rb

@@ -47,20 +47,18 @@ module Sequel
       class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
         Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
 
-        # The table containing the column to use for the associated key when eagerly loading
-        def associated_key_table
-          self[:associated_key_table] = self[:final_reverse_edge][:alias]
-        end
-        
         # The default associated key alias(es) to use when eager loading
         # associations via eager.
         def default_associated_key_alias
           self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
 
-        # The list of joins to use when eager graphing
-        def edges
-          self[:edges] || calculate_edges || self[:edges]
+        %w'associated_key_table predicate_key edges final_edge final_reverse_edge reverse_edges'.each do |meth|
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{meth}
+              cached_fetch(:#{meth}){calculate_edges[:#{meth}]}
+            end
+          END
         end
 
         # Many through many associations don't have a reciprocal
@@ -68,11 +66,6 @@ module Sequel
           nil
         end
 
-        # The list of joins to use when lazy loading or eager loading
-        def reverse_edges
-          self[:reverse_edges] || calculate_edges || self[:reverse_edges]
-        end
-
         private
 
         # Make sure to use unique table aliases when lazy loading or eager loading
@@ -94,7 +87,7 @@ module Sequel
 
         # Transform the :through option into a list of edges and reverse edges to use to join tables when loading the association.
         def calculate_edges
-          es = [{:left_table=>self[:model].table_name, :left_key=>self[:left_primary_key]}]
+          es = [{:left_table=>self[:model].table_name, :left_key=>self[:left_primary_key_column]}]
           self[:through].each do |t|
             es.last.merge!(:right_key=>t[:left], :right_table=>t[:table], :join_type=>t[:join_type]||self[:graph_join_type], :conditions=>(t[:conditions]||[]).to_a, :block=>t[:block])
             es.last[:only_conditions] = t[:only_conditions] if t.include?(:only_conditions)
@@ -109,37 +102,38 @@ module Sequel
           reverse_edges = es.reverse.map{|e| {:table=>e[:left_table], :left=>e[:left_key], :right=>e[:right_key]}}
           reverse_edges.pop
           calculate_reverse_edge_aliases(reverse_edges)
-          self[:final_edge] = edges.pop
-          self[:final_reverse_edge] = reverse_edges.pop
-          self[:edges] = edges
-          self[:reverse_edges] = reverse_edges
-          nil
+          final_reverse_edge = reverse_edges.pop
+          final_reverse_alias = final_reverse_edge[:alias]
+
+          h = {:final_edge=>edges.pop,
+               :final_reverse_edge=>final_reverse_edge,
+               :edges=>edges,
+               :reverse_edges=>reverse_edges,
+               :predicate_key=>qualify(final_reverse_alias, edges.first[:right]),
+               :associated_key_table=>final_reverse_edge[:alias],
+          }
+          h.each{|k, v| cached_set(k, v)}
+          h
         end
       end
+
       module ClassMethods
         # Create a many_through_many association.  Arguments:
         # * name - Same as associate, the name of the association.
         # * through - The tables and keys to join between the current table and the associated table.
         #   Must be an array, with elements that are either 3 element arrays, or hashes with keys :table, :left, and :right.
         #   The required entries in the array/hash are:
-        #   * :table (first array element) - The name of the table to join.
-        #   * :left (middle array element) - The key joining the table to the previous table. Can use an
-        #     array of symbols for a composite key association.
-        #   * :right (last array element) - The key joining the table to the next table. Can use an
-        #     array of symbols for a composite key association.
+        #   :table (first array element) :: The name of the table to join.
+        #   :left (middle array element) :: The key joining the table to the previous table. Can use an
+        #                                   array of symbols for a composite key association.
+        #   :right (last array element) :: The key joining the table to the next table. Can use an
+        #                                  array of symbols for a composite key association.
         #   If a hash is provided, the following keys are respected when using eager_graph:
-        #   * :block - A proc to use as the block argument to join.
-        #   * :conditions - Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
-        #   * :join_type - The join type to use for the join, defaults to :left_outer.
-        #   * :only_conditions - Conditions to use for the join instead of the ones specified by the keys.
-        # * opts - The options for the associaion.  Takes the same options as associate, and supports these additional options:
-        #   * :left_primary_key - column in current table that the first :left option in
-        #     through points to, as a symbol. Defaults to primary key of current table. Can use an
-        #     array of symbols for a composite key association.
-        #   * :right_primary_key - column in associated table that the final :right option in 
-        #     through points to, as a symbol. Defaults to primary key of the associated table.  Can use an
-        #     array of symbols for a composite key association.
-        #   * :uniq - Adds a after_load callback that makes the array of objects unique.
+        #   :block :: A proc to use as the block argument to join.
+        #   :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
+        #   :join_type :: The join type to use for the join, defaults to :left_outer.
+        #   :only_conditions :: Conditions to use for the join instead of the ones specified by the keys.
+        # * opts - The options for the associaion.  Takes the same options as many_to_many.
         def many_through_many(name, through, opts={}, &block)
           associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
         end
@@ -170,24 +164,41 @@ module Sequel
           uses_lcks = opts[:uses_left_composite_keys] = left_key.is_a?(Array)
           left_keys = Array(left_key)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
+          opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           left_pks = opts[:left_primary_keys] = Array(left_pk)
+          lpkc = opts[:left_primary_key_column] ||= left_pk
+          lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
           opts[:dataset] ||= lambda do
             ds = opts.associated_class
-            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-            ft = opts[:final_reverse_edge]
-            ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + left_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias])
+            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
+            ft = opts.final_reverse_edge
+            ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + opts.predicate_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias], :qualify=>:deep)
           end
 
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:eager_loader] ||= lambda do |eo|
-            h = eo[:key_hash][left_pk]
-            eo[:rows].each{|object| object.associations[name] = []}
+            h = eo[:id_map]
+            rows = eo[:rows]
+            rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
-            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-            ft = opts[:final_reverse_edge]
-            conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
-            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
-            model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
+            opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
+            ft = opts.final_reverse_edge
+            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.predicate_key, h.keys]], :table_alias=>ft[:alias], :qualify=>:deep)
+            ds = model.eager_loading_dataset(opts, ds, nil, eo[:associations], eo)
+            case opts.eager_limit_strategy
+            when :window_function
+              delete_rn = true
+              rn = ds.row_number_column
+              ds = apply_window_function_eager_limit_strategy(ds, opts)
+            when :correlated_subquery
+              ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
+                dsa = ds.send(:dataset_alias, 2)
+                opts.reverse_edges.each{|t| xds = xds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+                xds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + left_keys.map{|k| [k, SQL::QualifiedIdentifier.new(ft[:table], k)]}, :table_alias=>dsa, :qualify=>:deep)
+              end
+            end
+            ds.all do |assoc_record|
+              assoc_record.values.delete(rn) if delete_rn
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
@@ -196,6 +207,10 @@ module Sequel
               next unless objects = h[hash_key]
               objects.each{|object| object.associations[name].push(assoc_record)}
             end
+            if opts.eager_limit_strategy == :ruby
+              limit, offset = opts.limit_and_offset
+              rows.each{|o| o.associations[name] = o.associations[name].slice(offset||0, limit) || []}
+            end
           end
 
           join_type = opts[:graph_join_type]
@@ -204,19 +219,56 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           use_only_conditions = opts.include?(:graph_only_conditions)
           conditions = opts[:graph_conditions]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            iq = table_alias
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            iq = eo[:implicit_qualifier]
             opts.edges.each do |t|
-              ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
+              ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :qualify=>:deep, :implicit_qualifier=>iq, &t[:block])
               iq = nil
             end
-            fe = opts[:final_edge]
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+            fe = opts.final_edge
+            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>join_type, &graph_block)
           end
 
           def_association_dataset_methods(opts)
         end
       end
+
+      module DatasetMethods
+        private
+
+        # Use a subquery to filter rows to those related to the given associated object
+        def many_through_many_association_filter_expression(op, ref, obj)
+          lpks = ref[:left_primary_key_columns]
+          lpks = lpks.first if lpks.length == 1
+          lpks = ref.qualify(model.table_name, lpks)
+          edges = ref.edges
+          first, rest = edges.first, edges[1..-1]
+          last = edges.last
+          ds = model.db[first[:table]].select(*Array(ref.qualify(first[:table], first[:right])))
+          rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), :qualify=>:deep, &e[:block])}
+          last_alias = if rest.empty?
+            first[:table]
+          else
+            last_join = ds.opts[:join].last
+            last_join.table_alias || last_join.table
+          end
+
+          meths = if obj.is_a?(Sequel::Dataset)
+            ref.qualify(obj.model.table_name, ref.right_primary_keys)
+          else
+            ref.right_primary_key_methods
+          end
+
+          exp = association_filter_key_expression(ref.qualify(last_alias, Array(ref.final_edge[:left])), meths, obj)
+          if exp == SQL::Constants::FALSE
+            association_filter_handle_inversion(op, exp, Array(lpks))
+          else
+            ds = ds.where(exp).exclude(SQL::BooleanExpression.from_value_pairs(ds.opts[:select].zip([]), :OR))
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>ds), Array(lpks))
+          end
+        end
+      end
     end
   end
 end