sequel 3.21.0 → 3.24.0

data/lib/sequel/extensions/to_dot.rb

@@ -4,109 +4,111 @@
 # of the dataset's abstract syntax tree.
 
 module Sequel
-  class Dataset
+  class ToDot
     # The option keys that should be included in the dot output.
     TO_DOT_OPTIONS = [:with, :distinct, :select, :from, :join, :where, :group, :having, :compounds, :order, :limit, :offset, :lock].freeze
 
-    # Return a string that can be processed by the +dot+ program (included
-    # with graphviz) in order to see a visualization of the dataset's
-    # abstract syntax tree.
-    def to_dot
-      i = 0
-      dot = ["digraph G {", "#{i} [label=\"self\"];"]
-      _to_dot(dot, "", i, self, i)
-      dot << "}"
-      dot.join("\n")
+    # Given a +Dataset+, return a string in +dot+ format that will
+    # generate a visualization of the dataset.
+    def self.output(ds)
+      new(ds).output
+    end
+
+    # Given a +Dataset+, parse the internal structure to generate
+    # a dataset visualization.
+    def initialize(ds)
+      @i = 0
+      @stack = [@i]
+      @dot = ["digraph G {", "0 [label=\"self\"];"]
+      v(ds, "")
+      @dot << "}"
+    end
+
+    # Output the dataset visualization as a string in +dot+ format.
+    def output
+      @dot.join("\n")
     end
 
     private
 
-    # Internal recursive version that handles all object types understood
-    # by Sequel.  Arguments:
-    # * dot :: An array of strings representing the lines in the returned
-    #          output.  This function just pushes strings onto this array.
-    # * l :: The transition label from the parent node of the AST to the
-    #        current node.
-    # * c :: An integer representing the parent node of the AST.
-    # * e :: The current node of the AST.
-    # * i :: The integer representing the last created node of the AST.
-    #
-    # The basic algorithm is that the +i+ is incremented to get the current
-    # node's integer.  Then the transition from the parent node to the
-    # current node is added to the +dot+ array.  Finally, the current node
-    # is added to the +dot+ array, and if it is a compound node with children,
-    # its children are then added by recursively calling this method. The
-    # return value is the integer representing the last created node.
-    def _to_dot(dot, l, c, e, i)
-      i += 1
-      dot << "#{c} -> #{i} [label=\"#{l}\"];" if l
-      c = i
+    # Add an entry to the +dot+ output with the given label.  If +j+
+    # is given, it is used directly as the node or transition.  Otherwise
+    # a node is created for the current object.
+    def dot(label, j=nil)
+      @dot << "#{j||@i} [label=#{label.to_s.inspect}];"
+    end
+
+    # Recursive method that parses all of Sequel's internal datastructures,
+    # adding the appropriate nodes and transitions to the internal +dot+
+    # structure.
+    def v(e, l)
+      @i += 1
+      dot(l, "#{@stack.last} -> #{@i}") if l
+      @stack.push(@i)
       case e
       when LiteralString
-        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}.lit\"];"
-        i
+        dot "#{e.inspect}.lit"
       when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
-        dot << "#{i} [label=\"#{e.inspect.gsub('"', '\\"')}\"];"
-        i
+        dot e.inspect
       when Array
-        dot << "#{i} [label=\"Array\"];"
-        e.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "Array"
+        e.each_with_index do |val, j|
+          v(val, j)
         end
       when Hash
-        dot << "#{i} [label=\"Hash\"];"
-        e.each do |k, v|
-          i = _to_dot(dot, k, c, v, i)
+        dot "Hash"
+        e.each do |k, val|
+          v(val, k)
         end
       when SQL::ComplexExpression 
-        dot << "#{i} [label=\"ComplexExpression: #{e.op}\"];"
-        e.args.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "ComplexExpression: #{e.op}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
         end
       when SQL::Identifier
-        dot << "#{i} [label=\"Identifier\"];"
-        i = _to_dot(dot, :value, c, e.value, i)
+        dot "Identifier"
+        v(e.value, :value)
       when SQL::QualifiedIdentifier
-        dot << "#{i} [label=\"QualifiedIdentifier\"];"
-        i = _to_dot(dot, :table, c, e.table, i)
-        i = _to_dot(dot, :column, c, e.column, i)
+        dot "QualifiedIdentifier"
+        v(e.table, :table)
+        v(e.column, :column)
       when SQL::OrderedExpression
-        dot << "#{i} [label=\"OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i)
+        dot "OrderedExpression: #{e.descending ? :DESC : :ASC}#{" NULLS #{e.nulls.to_s.upcase}" if e.nulls}"
+        v(e.expression, :expression)
       when SQL::AliasedExpression
-        dot << "#{i} [label=\"AliasedExpression\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i)
-        i = _to_dot(dot, :alias, c, e.aliaz, i)
+        dot "AliasedExpression"
+        v(e.expression, :expression)
+        v(e.aliaz, :alias)
       when SQL::CaseExpression
-        dot << "#{i} [label=\"CaseExpression\"];"
-        i = _to_dot(dot, :expression, c, e.expression, i) if e.expression
-        i = _to_dot(dot, :conditions, c, e.conditions, i)
-        i = _to_dot(dot, :default, c, e.default, i)
+        dot "CaseExpression"
+        v(e.expression, :expression) if e.expression
+        v(e.conditions, :conditions)
+        v(e.default, :default)
       when SQL::Cast
-        dot << "#{i} [label=\"Cast\"];"
-        i = _to_dot(dot, :expr, c, e.expr, i)
-        i = _to_dot(dot, :type, c, e.type, i)
+        dot "Cast"
+        v(e.expr, :expr)
+        v(e.type, :type)
       when SQL::Function
-        dot << "#{i} [label=\"Function: #{e.f}\"];"
-        e.args.each_with_index do |v, j|
-          i = _to_dot(dot, j, c, v, i)
+        dot "Function: #{e.f}"
+        e.args.each_with_index do |val, j|
+          v(val, j)
         end
       when SQL::Subscript 
-        dot << "#{i} [label=\"Subscript: #{e.f}\"];"
-        i = _to_dot(dot, :f, c, e.f, i)
-        i = _to_dot(dot, :sub, c, e.sub, i)
+        dot "Subscript"
+        v(e.f, :f)
+        v(e.sub, :sub)
       when SQL::WindowFunction
-        dot << "#{i} [label=\"WindowFunction\"];"
-        i = _to_dot(dot, :function, c, e.function, i)
-        i = _to_dot(dot, :window, c, e.window, i)
+        dot "WindowFunction"
+        v(e.function, :function)
+        v(e.window, :window)
       when SQL::Window
-        dot << "#{i} [label=\"Window\"];"
-        i = _to_dot(dot, :opts, c, e.opts, i)
+        dot "Window"
+        v(e.opts, :opts)
       when SQL::PlaceholderLiteralString
         str = e.str
         str = "(#{str})" if e.parens
-        dot << "#{i} [label=\"PlaceholderLiteralString: #{str.inspect.gsub('"', '\\"')}\"];"
-        i = _to_dot(dot, :args, c, e.args, i)
+        dot "PlaceholderLiteralString: #{str.inspect}"
+        v(e.args, :args)
       when SQL::JoinClause
         str = "#{e.join_type.to_s.upcase} JOIN"
         if e.is_a?(SQL::JoinOnClause)
@@ -114,24 +116,34 @@ module Sequel
         elsif e.is_a?(SQL::JoinUsingClause)
           str << " USING"
         end
-        dot << "#{i} [label=\"#{str}\"];"
-        i = _to_dot(dot, :table, c, e.table, i)
-        i = _to_dot(dot, :alias, c, e.table_alias, i) if e.table_alias
+        dot str
+        v(e.table, :table)
+        v(e.table_alias, :alias) if e.table_alias
         if e.is_a?(SQL::JoinOnClause)
-          i = _to_dot(dot, :on, c, e.on, i)
+          v(e.on, :on) 
         elsif e.is_a?(SQL::JoinUsingClause)
-          i = _to_dot(dot, :using, c, e.using, i)
+          v(e.using, :using) 
         end
       when Dataset
-        dot << "#{i} [label=\"Dataset\"];"
+        dot "Dataset"
         TO_DOT_OPTIONS.each do |k|
-          next unless e.opts[k]
-          i = _to_dot(dot, k, c, e.opts[k], i)
+          if val = e.opts[k]
+            v(val, k.to_s) 
+          end
         end
       else
-        dot << "#{i} [label=\"Unhandled: #{e.inspect.gsub('"', "''")}\"];"
+        dot "Unhandled: #{e.inspect}"
       end
-      i
+      @stack.pop
+    end
+  end
+
+  class Dataset
+    # Return a string that can be processed by the +dot+ program (included
+    # with graphviz) in order to see a visualization of the dataset's
+    # abstract syntax tree.
+    def to_dot
+      ToDot.output(self)
     end
   end
 end

data/lib/sequel/model/associations.rb

@@ -529,8 +529,12 @@ module Sequel
         #     set to nil.
         #   - :eager_graph - The associations to eagerly load via +eager_graph+ when loading the associated object(s).
         #   - :eager_grapher - A proc to use to implement eager loading via +eager_graph+, overriding the default.
-        #     Takes three arguments, a dataset, an alias to use for the table to graph for this association,
-        #     and the alias that was used for the current table (since you can cascade associations),
+        #     Takes one or three arguments. If three arguments, they are a dataset, an alias to use for
+        #     the table to graph for this association, and the alias that was used for the current table
+        #     (since you can cascade associations). If one argument, is passed a hash with keys :self,
+        #     :table_alias, and :implicit_qualifier, corresponding to the three arguments, and an optional
+        #     additional key :eager_block, a callback accepting one argument, the associated dataset. This
+        #     is used to customize the association at query time.
         #     Should return a copy of the dataset with the association graphed into it.
         #   - :eager_loader - A proc to use to implement eager loading, overriding the default.  Takes one or three arguments.
         #     If three arguments, the first should be a key hash (used solely to enhance performance), the second an array of records,
@@ -628,7 +632,8 @@ module Sequel
           raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
           raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
           raise(Error, ':eager_loader option must have an arity of 1 or 3') if opts[:eager_loader] && ![1, 3].include?(opts[:eager_loader].arity)
-      
+          raise(Error, ':eager_grapher option must have an arity of 1 or 3') if opts[:eager_grapher] && ![1, 3].include?(opts[:eager_grapher].arity)
+
           # dup early so we don't modify opts
           orig_opts = opts.dup
           orig_opts = association_reflection(opts[:clone])[:orig_opts].merge(orig_opts) if opts[:clone]
@@ -678,16 +683,18 @@ module Sequel
           if opts[:eager_graph]
             ds = ds.eager_graph(opts[:eager_graph])
             ds = ds.add_graph_aliases(opts.associated_key_alias=>[opts.associated_class.table_name, opts.associated_key_alias, SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column)]) if opts.eager_loading_use_associated_key?
-          elsif opts.eager_loading_use_associated_key?
+          end
+          ds = ds.eager(associations) unless Array(associations).empty?
+          ds = opts[:eager_block].call(ds) if opts[:eager_block]
+          ds = eager_options[:eager_block].call(ds) if eager_options[:eager_block]
+          if !opts[:eager_graph] && opts.eager_loading_use_associated_key?
             ds = if opts[:uses_left_composite_keys]
               t = opts.associated_key_table
-              ds.select_more(*opts.associated_key_alias.zip(opts.associated_key_column).map{|a, c| SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, c), a)})
+              ds.select_append(*opts.associated_key_alias.zip(opts.associated_key_column).map{|a, c| SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(t, c), a)})
             else
-              ds.select_more(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias)) 
+              ds.select_append(SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(opts.associated_key_table, opts.associated_key_column), opts.associated_key_alias))
             end
           end
-          ds = ds.eager(associations) unless Array(associations).empty?
-          ds = opts[:eager_block].call(ds) if opts[:eager_block]
           ds
         end
 
@@ -753,9 +760,20 @@ module Sequel
           def_association_method(opts)
         end
 
-        # Adds the association method to the association methods module. 
-        def def_association_method(opts)
-          association_module_def(opts.association_method, opts){|*reload| load_associated_objects(opts, reload[0])}
+        # Adds the association method to the association methods module. Be backwards
+        # compatible with ruby 1.8.6, which doesn't support blocks taking block arguments.
+        if RUBY_VERSION >= '1.8.7'
+          class_eval <<-END, __FILE__, __LINE__+1
+            def def_association_method(opts)
+              association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
+            end
+          END
+        else
+          class_eval <<-END, __FILE__, __LINE__+1
+            def def_association_method(opts)
+              association_module_def(opts.association_method, opts){|*dynamic_opts| load_associated_objects(opts, dynamic_opts[0])}
+            end
+          END
         end
       
         # Configures many_to_many association reflection and adds the related association methods
@@ -782,8 +800,7 @@ module Sequel
           opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
           opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
           opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + lcks.zip(lcpks.map{|k| send(k)}))}
-          database = db
-          
+
           opts[:eager_loader] ||= proc do |eo|
             h = eo[:key_hash][left_pk]
             eo[:rows].each{|object| object.associations[name] = []}
@@ -810,9 +827,10 @@ module Sequel
           jt_only_conditions = opts[:graph_join_table_only_conditions]
           jt_join_type = opts[:graph_join_table_join_type]
           jt_graph_block = opts[:graph_join_table_block]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table), :join_type=>jt_join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, &graph_block)
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -876,8 +894,9 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           conditions = opts[:graph_conditions]
           graph_block = opts[:graph_block]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds.graph(opts.associated_class, use_only_conditions ? only_conditions : opts.primary_keys.zip(cks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &graph_block)
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -936,10 +955,11 @@ module Sequel
           conditions = opts[:graph_conditions]
           opts[:cartesian_product_number] ||= one_to_one ? 0 : 1
           graph_block = opts[:graph_block]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            ds = ds.graph(opts.associated_class, use_only_conditions ? only_conditions : cks.zip(cpks) + conditions, :select=>select, :table_alias=>assoc_alias, :join_type=>join_type, :implicit_qualifier=>table_alias, :from_self_alias=>ds.opts[:eager_graph][:master], &graph_block)
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            ds = ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : cks.zip(cpks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
-            ds.opts[:eager_graph][:reciprocals][assoc_alias] = opts.reciprocal
+            ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
           end
       
@@ -993,6 +1013,15 @@ module Sequel
           association_module_def(opts.remove_method, opts){|o,*args| remove_associated_object(opts, o, *args)}
           association_module_def(opts.remove_all_method, opts){|*args| remove_all_associated_objects(opts, *args)}
         end
+
+        # 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 cb = eager_options[:callback]
+            ds = cb.call(ds)
+          end
+          ds
+        end
       end
 
       # Instance methods used to implement the associations support.
@@ -1033,6 +1062,15 @@ module Sequel
           ds
         end
 
+        # Return a dataset for the association after applying any dynamic callback.
+        def _associated_dataset(opts, dynamic_opts)
+          ds = send(opts.dataset_method)
+          if callback = dynamic_opts[:callback]
+            ds = callback.call(ds)
+          end
+          ds
+        end
+        
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
@@ -1045,13 +1083,14 @@ module Sequel
           opts[:join_table_block] ? opts[:join_table_block].call(ds) : ds
         end
 
-        # Return the associated objects from the dataset, without callbacks, reciprocals, and caching.
-        def _load_associated_objects(opts)
+        # Return the associated objects from the dataset, without association callbacks, reciprocals, and caching.
+        # Still apply the dynamic callback if present.
+        def _load_associated_objects(opts, dynamic_opts={})
           if opts.returns_array?
-            opts.can_have_associated_objects?(self) ? send(opts.dataset_method).all : []
+            opts.can_have_associated_objects?(self) ? _associated_dataset(opts, dynamic_opts).all : []
           else
             if opts.can_have_associated_objects?(self)
-              send(opts.dataset_method).all.first
+              _associated_dataset(opts, dynamic_opts).all.first
             end
           end
         end
@@ -1113,12 +1152,20 @@ module Sequel
         end
 
         # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
-        def load_associated_objects(opts, reload=false)
+        def load_associated_objects(opts, dynamic_opts=nil)
+          if dynamic_opts == true or dynamic_opts == false or dynamic_opts == nil
+            dynamic_opts = {:reload=>dynamic_opts}
+          elsif dynamic_opts.respond_to?(:call)
+            dynamic_opts = {:callback=>dynamic_opts}
+          end
+          if block_given?
+            dynamic_opts = dynamic_opts.merge(:callback=>Proc.new)
+          end
           name = opts[:name]
-          if associations.include?(name) and !reload
+          if associations.include?(name) and !dynamic_opts[:callback] and !dynamic_opts[:reload]
             associations[name]
           else
-            objs = _load_associated_objects(opts)
+            objs = _load_associated_objects(opts, dynamic_opts)
             run_association_callbacks(opts, :after_load, objs)
             if opts.set_reciprocal_to_self?
               if opts.returns_array?
@@ -1259,6 +1306,24 @@ module Sequel
       #   Artist.eager_graph(:albums=>:tracks).all
       #   Artist.eager(:albums=>{:tracks=>:genre}).all
       #   Artist.eager_graph(:albums=>{:tracks=>:genre}).all
+      #
+      # You can also pass a callback as a hash value in order to customize the dataset being
+      # eager loaded at query time, analogous to the way the :eager_block association option
+      # allows you to customize it at association definition time. For example,
+      # if you wanted artists with their albums since 1990:
+      #
+      #   Artist.eager(:albums => proc{|ds| ds.filter{year > 1990}})
+      #
+      # Or if you needed albums and their artist's name only, using a single query:
+      #
+      #   Albums.eager_graph(:artist => proc{|ds| ds.select(:name)})
+      #
+      # To cascade eager loading while using a callback, you substitute the cascaded
+      # associations with a single entry hash that has the proc callback as the key and 
+      # the cascaded associations as the value.  This will load artists with their albums
+      # since 1990, and also the tracks on those albums and the genre for those tracks:
+      #
+      #   Artist.eager(:albums => {proc{|ds| ds.filter{year > 1990}}=>{:tracks => :genre}})
       module DatasetMethods
         # Add the <tt>eager!</tt> and <tt>eager_graph!</tt> mutation methods to the dataset.
         def self.extended(obj)
@@ -1343,6 +1408,55 @@ module Sequel
           ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations)
         end
         
+        # If the expression is in the form <tt>x = y</tt> where +y+ is a <tt>Sequel::Model</tt>
+        # instance, assume +x+ is an association symbol and look up the association reflection
+        # via the dataset's model.  From there, return the appropriate SQL based on the type of
+        # association and the values of the foreign/primary keys of +y+.  For most association
+        # types, this is a simple transformation, but for +many_to_many+ associations this 
+        # creates a subquery to the join table.
+        def complex_expression_sql(op, args)
+          r = args.at(1)
+          if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
+              (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
+            l = args.at(0)
+            if ar = model.association_reflections[l]
+              if multiple
+                klass = ar.associated_class
+                if is_ds
+                  if r.respond_to?(:model)
+                    unless r.model <= klass
+                      # A dataset for a different model class, could be a valid regular query
+                      return super
+                    end
+                  else
+                    # Not a model dataset, could be a valid regular query
+                    return super
+                  end
+                else
+                  unless r.all?{|x| x.is_a?(klass)}
+                    raise Sequel::Error, "invalid association class for one object for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{klass.inspect}"
+                  end
+                end
+              elsif !r.is_a?(ar.associated_class)
+                raise Sequel::Error, "invalid association class #{r.class.inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}, expected class #{ar.associated_class.inspect}"
+              end
+
+              if exp = association_filter_expression(op, ar, r)
+                literal(exp)
+              else
+                raise Sequel::Error, "invalid association type #{ar[:type].inspect} for association #{l.inspect} used in dataset filter for model #{model.inspect}"
+              end
+            elsif multiple && (is_ds || r.empty?)
+              # Not a query designed for this support, could be a valid regular query
+              super
+            else
+              raise Sequel::Error, "invalid association #{l.inspect} used in dataset filter for model #{model.inspect}"
+            end
+          else
+            super
+          end
+        end
+
         # Do not attempt to split the result set into associations,
         # just return results as simple objects.  This is useful if you
         # want to use eager_graph as a shortcut to have all of the joins
@@ -1366,10 +1480,23 @@ module Sequel
         # r :: association reflection for the current association
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
-          klass = r.associated_class
           assoc_name = r[:name]
           assoc_table_alias = ds.unused_table_alias(assoc_name)
-          ds = r[:eager_grapher].call(ds, assoc_table_alias, ta)
+          loader = r[:eager_grapher]
+          if !associations.empty?
+            if associations.first.respond_to?(:call)
+              callback = associations.first
+              associations = {}
+            elsif associations.length == 1 && (assocs = associations.first).is_a?(Hash) && assocs.length == 1 && (pr_assoc = assocs.to_a.first) && pr_assoc.first.respond_to?(:call)
+              callback, assoc = pr_assoc
+              associations = assoc.is_a?(Array) ? assoc : [assoc]
+            end
+          end
+          ds = if loader.arity == 1
+            loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>ta, :callback=>callback)
+          else
+            loader.call(ds, assoc_table_alias, ta)
+          end
           ds = ds.order_more(*qualified_expression(r[:order], assoc_table_alias)) if r[:order] and r[:order_eager_graph]
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup
@@ -1471,6 +1598,49 @@ module Sequel
       
         private
       
+        # Return an expression for filtering by the given association reflection and associated object.
+        def association_filter_expression(op, ref, obj)
+          meth = :"#{ref[:type]}_association_filter_expression"
+          send(meth, op, ref, obj) if respond_to?(meth, true)
+        end
+
+        # Handle inversion for association filters by returning an inverted expression,
+        # plus also handling cases where the referenced columns are NULL.
+        def association_filter_handle_inversion(op, exp, cols)
+          if op == :'!=' || op == :'NOT IN'
+            if exp == SQL::Constants::FALSE
+              ~exp
+            else
+              ~exp | Sequel::SQL::BooleanExpression.from_value_pairs(cols.zip([]), :OR)
+            end
+          else
+            exp
+          end
+        end
+
+        # Return an expression for making sure that the given keys match the value of
+        # the given methods for either the single object given or for any of the objects
+        # given if +obj+ is an array.
+        def association_filter_key_expression(keys, meths, obj)
+          vals = if obj.is_a?(Sequel::Dataset)
+            {(keys.length == 1 ? keys.first : keys)=>obj.select(*meths).exclude(Sequel::SQL::BooleanExpression.from_value_pairs(meths.zip([]), :OR))}
+          else
+            vals = Array(obj).reject{|o| !meths.all?{|m| o.send(m)}}
+            return SQL::Constants::FALSE if vals.empty?
+            if obj.is_a?(Array)
+              if keys.length == 1
+                meth = meths.first
+                {keys.first=>vals.map{|o| o.send(meth)}}
+              else
+                {keys=>vals.map{|o| meths.map{|m| o.send(m)}}}
+              end  
+            else
+              keys.zip(meths.map{|k| obj.send(k)})
+            end
+          end
+          SQL::BooleanExpression.from_value_pairs(vals)
+        end
+
         # Make sure the association is valid for this model, and return the related AssociationReflection.
         def check_association(model, association)
           raise(Sequel::UndefinedAssociation, "Invalid association #{association} for #{model.name}") unless reflection = model.association_reflection(association)
@@ -1557,15 +1727,47 @@ module Sequel
           
           reflections.each do |r|
             loader = r[:eager_loader]
+            associations = eager_assoc[r[:name]]
+            if associations.respond_to?(:call)
+              eager_block = associations
+              associations = {}
+            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
             if loader.arity == 1
-              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>eager_assoc[r[:name]], :self=>self)
+              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block)
             else
-              loader.call(key_hash, a, eager_assoc[r[:name]])
+              loader.call(key_hash, a, associations)
             end
             a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} unless r[:after_load].empty?
           end 
         end
       
+        # Return a subquery expression for filering by a many_to_many association
+        def many_to_many_association_filter_expression(op, ref, obj)
+          lpks, lks, rks = ref.values_at(:left_primary_keys, :left_keys, :right_keys)
+          lpks = lpks.first if lpks.length == 1
+          exp = association_filter_key_expression(rks, ref.right_primary_keys, obj)
+          if exp == SQL::Constants::FALSE
+            association_filter_handle_inversion(op, exp, Array(lpks))
+          else
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>model.db[ref[:join_table]].select(*lks).where(exp).exclude(SQL::BooleanExpression.from_value_pairs(lks.zip([]), :OR))), Array(lpks))
+          end
+        end
+
+        # Return a simple equality expression for filering by a many_to_one association
+        def many_to_one_association_filter_expression(op, ref, obj)
+          keys = ref[:keys]
+          association_filter_handle_inversion(op, association_filter_key_expression(keys, ref.primary_keys, obj), keys)
+        end
+
+        # Return a simple equality expression for filering by a one_to_* association
+        def one_to_many_association_filter_expression(op, ref, obj)
+          keys = ref[:primary_keys]
+          association_filter_handle_inversion(op, association_filter_key_expression(keys, ref[:keys], obj), keys)
+        end
+        alias one_to_one_association_filter_expression one_to_many_association_filter_expression
+
         # Build associations from the graph if #eager_graph was used, 
         # and/or load other associations if #eager was used.
         def post_load(all_records)