sequel 3.36.1 → 3.37.0

data/lib/sequel/extensions/sql_expr.rb

@@ -7,6 +7,10 @@
 #   true.sql_expr | :a  # TRUE OR a
 #   ~nil.sql_expr       # NOT NULL
 #   "a".sql_expr + "b"  # 'a' || 'b'
+#
+# To load the extension:
+#
+#   Sequel.extension :sql_expr
 
 class Object
   # Return the object wrapper in an appropriate Sequel expression object.

data/lib/sequel/extensions/string_date_time.rb

@@ -1,6 +1,10 @@
 # The string_date_time extension provides String instance methods
 # for converting the strings to a date (e.g. String#to_date), allowing
 # for backwards compatibility with legacy Sequel code.
+#
+# To load the extension:
+#
+#   Sequel.extension :string_date_time
 
 class String
   # Converts a string into a Date object.

data/lib/sequel/extensions/thread_local_timezones.rb

@@ -1,9 +1,15 @@
 # The thread_local_timezones extension allows you to set a per-thread timezone that
 # will override the default global timezone while the thread is executing.  The
 # main use case is for web applications that execute each request in its own thread,
-# and want to set the timezones based on the request.  The most common example
-# is having the database always store time in UTC, but have the application deal
-# with the timezone of the current user.  That can be done with:
+# and want to set the timezones based on the request.
+#
+# To load the extension:
+#
+#   Sequel.extension :thread_local_timezones
+#
+# The most common example is having the database always store time in
+# UTC, but have the application deal with the timezone of the current
+# user.  That can be done with:
 #
 #   Sequel.database_timezone = :utc
 #   # In each thread:

data/lib/sequel/extensions/to_dot.rb

@@ -2,6 +2,10 @@
 # returns a string that can be processed by graphviz's +dot+ program in
 # order to get a visualization of the dataset.  Basically, it shows a version
 # of the dataset's abstract syntax tree.
+#
+# To load the extension:
+#
+#   Sequel.extension :to_dot
 
 module Sequel
   class ToDot

data/lib/sequel/model/associations.rb

@@ -100,12 +100,22 @@ module Sequel
           end
         end
 
+        # The key to use for the key hash when eager loading
+        def eager_loader_key
+          self[:eager_loader_key]
+        end
+    
         # By default associations do not need to select a key in an associated table
         # to eagerly load.
         def eager_loading_use_associated_key?
           false
         end
 
+        # Alias of predicate_key, only for backwards compatibility.
+        def eager_loading_predicate_key
+          predicate_key
+        end
+
         # Whether to eagerly graph a lazy dataset, true by default.  If this
         # is false, the association won't respect the :eager_graph option
         # when loading the association for a single record.
@@ -128,10 +138,23 @@ module Sequel
           false
         end
 
+        # The keys to use for loading of the regular dataset, as an array.
+        def predicate_keys
+          cached_fetch(:predicate_keys){Array(predicate_key)}
+        end
+
         # Qualify +col+ with the given table name.  If +col+ is an array of columns,
-        # return an array of qualified columns.
+        # return an array of qualified columns.  Only qualifies Symbols and SQL::Identifier
+        # values, other values are not modified.
         def qualify(table, col)
-          transform(col){|k| SQL::QualifiedIdentifier.new(table, k)}
+          transform(col) do |k|
+            case k
+            when Symbol, SQL::Identifier
+              SQL::QualifiedIdentifier.new(table, k)
+            else
+              Sequel::Qualifier.new(self[:model].dataset, table).transform(k)
+            end
+          end
         end
 
         # Qualify col with the associated model's table name.
@@ -288,11 +311,11 @@ module Sequel
           nil
         end
 
-        # The key to use for the key hash when eager loading
-        def eager_loader_key
-          cached_fetch(:eager_loader_key){self[:key]}
+        # The expression to use on the left hand side of the IN lookup when eager loading
+        def predicate_key
+          cached_fetch(:predicate_key){qualified_primary_key}
         end
-    
+
         # The column(s) in the associated table that the key in the current table references (either a symbol or an array).
         def primary_key
          cached_fetch(:primary_key){associated_class.primary_key}
@@ -367,16 +390,11 @@ module Sequel
           :"#{underscore(demodulize(self[:model].name))}_id"
         end
         
-        # The key to use for the key hash when eager loading
-        def eager_loader_key
-          cached_fetch(:eager_loader_key){primary_key}
-        end
-
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
-        def eager_loading_predicate_key
-          cached_fetch(:eager_loading_predicate_key){qualify_assoc(self[:key])}
+        def predicate_key
+          cached_fetch(:predicate_key){qualify_assoc(self[:key])}
         end
-        alias qualified_key eager_loading_predicate_key
+        alias qualified_key predicate_key
     
         # The column in the current table that the key in the associated table references.
         def primary_key
@@ -498,17 +516,12 @@ module Sequel
           :"#{singularize(self[:name])}_id"
         end
       
-        # The key to use for the key hash when eager loading
-        def eager_loader_key
-          cached_fetch(:eager_loader_key){self[:left_primary_key]}
-        end
-    
         # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3)).
         # The left key qualified by the join table.
-        def eager_loading_predicate_key
-          cached_fetch(:eager_loading_predicate_key){qualify(join_table_alias, self[:left_key])}
+        def predicate_key
+          cached_fetch(:predicate_key){qualify(join_table_alias, self[:left_key])}
         end
-        alias qualified_left_key eager_loading_predicate_key
+        alias qualified_left_key predicate_key
 
         # The right key qualified by the join table.
         def qualified_right_key
@@ -765,15 +778,15 @@ module Sequel
         #                          choice for the database, or specify a specific symbol to manually select a strategy.
         #                          one_to_one associations support :distinct_on, :window_function, and :correlated_subquery.
         #                          *_many associations support :ruby, :window_function, and :correlated_subquery.
-        # :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, and the third a hash of dependent associations. If one argument, is
-        #                  passed a hash with keys :key_hash, :rows, and :associations, corresponding to the three
-        #                  arguments, and an additional key :self, which is the dataset doing the eager loading. In the
-        #                  proc, the associated records should be queried from the database and the associations cache for
-        #                  each record should be populated.
-        # :eager_loader_key :: A symbol for the key column to use to populate the key hash
-        #                      for the eager loader.
+        # :eager_loader :: A proc to use to implement eager loading, overriding the default.  Takes a single hash argument,
+        #                  with at least the keys: :rows, which is an array of current model instances, :associations,
+        #                  which is a hash of dependent associations, :self, which is the dataset doing the eager loading,
+        #                  :eager_block, which is a dynamic callback that should be called with the dataset, and :id_map,
+        #                  which is a mapping of key values to arrays of current model instances. In the proc, the
+        #                  associated records should be queried from the database and the associations cache for each
+        #                  record should be populated.
+        # :eager_loader_key :: A symbol for the key column to use to populate the key_hash
+        #                      for the eager loader.  Can be set to nil to not populate the key_hash.
         # :extend :: A module or array of modules to extend the dataset with.
         # :graph_alias_base :: The base name to use for the table alias when eager graphing.  Defaults to the name
         #                      of the association.  If the alias name has already been used in the query, Sequel will create
@@ -894,11 +907,18 @@ module Sequel
 
           # 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]
+          if opts[:clone]
+            cloned_assoc = association_reflection(opts[:clone])
+            raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})") unless cloned_assoc[:type] == type || [cloned_assoc[:type], type].all?{|t| [:one_to_many, :one_to_one].include?(t)}
+            orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
+          end
           opts = orig_opts.merge(:type => type, :name => name, :cache=>{}, :model => self)
           opts[:block] = block if block
           opts = assoc_class.new.merge!(opts)
           opts[:eager_block] = block unless opts.include?(:eager_block)
+          if !opts.has_key?(:predicate_key) && opts.has_key?(:eager_loading_predicate_key)
+            opts[:predicate_key] = opts[:eager_loading_predicate_key]
+          end
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
           conds = opts[:conditions]
@@ -945,9 +965,9 @@ module Sequel
           ds = eager_options[:eager_block].call(ds) if eager_options[:eager_block]
           if opts.eager_loading_use_associated_key?
             ds = if opts[:uses_left_composite_keys]
-              ds.select_append(*opts.associated_key_alias.zip(opts.eager_loading_predicate_key).map{|a, k| SQL::AliasedExpression.new(k, a)})
+              ds.select_append(*opts.associated_key_alias.zip(opts.predicate_keys).map{|a, k| SQL::AliasedExpression.new(k, a)})
             else
-              ds.select_append(SQL::AliasedExpression.new(opts.eager_loading_predicate_key, opts.associated_key_alias))
+              ds.select_append(SQL::AliasedExpression.new(opts.predicate_key, opts.associated_key_alias))
             end
           end
           ds
@@ -1038,7 +1058,7 @@ module Sequel
         def apply_window_function_eager_limit_strategy(ds, opts)
           rn = ds.row_number_column 
           limit, offset = opts.limit_and_offset
-          ds = ds.unordered.select_append{row_number(:over, :partition=>opts.eager_loading_predicate_key, :order=>ds.opts[:order]){}.as(rn)}.from_self
+          ds = ds.unordered.select_append{row_number(:over, :partition=>opts.predicate_key, :order=>ds.opts[:order]){}.as(rn)}.from_self
           ds = if opts[:type] == :one_to_one
             ds.where(rn => 1)
           elsif offset
@@ -1097,10 +1117,10 @@ module Sequel
           right = (opts[:right_key] ||= opts.default_right_key)
           rcks = opts[:right_keys] = Array(right)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
+          opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           lcpks = opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
           lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
-          elk = opts.eager_loader_key
           raise(Error, "mismatched number of left composite keys: #{lcks.inspect} vs #{lcpks.inspect}") unless lcks.length == lcpks.length
           if opts[:right_primary_key]
             rcpks = Array(opts[:right_primary_key])
@@ -1114,15 +1134,15 @@ module Sequel
           graph_jt_conds = opts[:graph_join_table_conditions] = opts.fetch(:graph_join_table_conditions, []).to_a
           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)}))}
+          opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + opts.predicate_keys.zip(lcpks.map{|k| send(k)}), :qualify=>:deep)}
 
           opts[:eager_loader] ||= proc do |eo|
-            h = eo[:key_hash][elk]
+            h = eo[:id_map]
             rows = eo[:rows]
             rows.each{|object| object.associations[name] = []}
             r = rcks.zip(opts.right_primary_keys)
-            l = [[opts.qualify(opts.join_table_alias, left), h.keys]]
-            ds = model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l), nil, eo[:associations], eo)
+            l = [[opts.predicate_key, h.keys]]
+            ds = model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, r + l, :qualify=>:deep), nil, eo[:associations], eo)
             case opts.eager_limit_strategy
             when :window_function
               delete_rn = true
@@ -1131,7 +1151,7 @@ module Sequel
             when :correlated_subquery
               ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
                 dsa = ds.send(:dataset_alias, 2)
-                xds.inner_join(join_table, r + lcks.map{|k| [k, SQL::QualifiedIdentifier.new(opts.join_table_alias, k)]}, :table_alias=>dsa)
+                xds.inner_join(join_table, r + lcks.map{|k| [k, SQL::QualifiedIdentifier.new(opts.join_table_alias, k)]}, :table_alias=>dsa, :qualify=>:deep)
               end
             end
             ds.all do |assoc_record|
@@ -1162,8 +1182,8 @@ module Sequel
           jt_graph_block = opts[:graph_join_table_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :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)
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :qualify=>:deep, :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], :qualify=>:deep, :join_type=>join_type, &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -1191,14 +1211,12 @@ module Sequel
         def def_many_to_one(opts)
           name = opts[:name]
           model = self
-          opts[:key] = opts.default_key unless opts.include?(:key)
-          key_column = key = opts[:key]
+          opts[:key] = opts.default_key unless opts.has_key?(:key)
+          key = opts[:key]
+          opts[:eager_loader_key] = key unless opts.has_key?(:eager_loader_key)
           cks = opts[:graph_keys] = opts[:keys] = Array(key)
-          if opts[:key_column]
-            key_column = opts[:key_column]
-            opts[:eager_loader_key] ||= key_column
-            opts[:graph_keys] = Array(key_column)
-          end
+          opts[:key_column] ||= key
+          opts[:graph_keys] = opts[:key_columns] = Array(opts[:key_column])
           opts[:qualified_key] = opts.qualify_cur(key)
           if opts[:primary_key]
             cpks = Array(opts[:primary_key])
@@ -1209,10 +1227,10 @@ module Sequel
           opts[:cartesian_product_number] ||= 0
           opts[:dataset] ||= proc do
             klass = opts.associated_class
-            klass.filter(Array(opts.qualified_primary_key).zip(cks.map{|k| send(k)}))
+            klass.filter(opts.predicate_keys.zip(cks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
-            h = eo[:key_hash][key_column]
+            h = eo[:id_map]
             keys = h.keys
             # Default the cached association to nil, so any object that doesn't have it
             # populated will have cached the negative lookup.
@@ -1220,7 +1238,7 @@ module Sequel
             # Skip eager loading if no objects have a foreign key for this association
             unless keys.empty?
               klass = opts.associated_class
-              model.eager_loading_dataset(opts, klass.filter(opts.qualified_primary_key=>keys), nil, eo[:associations], eo).all do |assoc_record|
+              model.eager_loading_dataset(opts, klass.filter(opts.predicate_key=>keys), nil, eo[:associations], eo).all do |assoc_record|
                 hash_key = uses_cks ? opts.primary_key_methods.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key_method)
                 next unless objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
@@ -1237,7 +1255,7 @@ module Sequel
           graph_cks = opts[:graph_keys]
           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(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.primary_keys.zip(graph_cks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :qualify=>:deep, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
           end
       
           def_association_dataset_methods(opts)
@@ -1256,18 +1274,19 @@ module Sequel
           key = (opts[:key] ||= opts.default_key)
           km = opts[:key_method] ||= opts[:key]
           cks = opts[:keys] = Array(key)
+          opts[:key_methods] = Array(opts[:key_method])
           primary_key = (opts[:primary_key] ||= self.primary_key)
+          opts[:eager_loader_key] = primary_key unless opts.has_key?(:eager_loader_key)
           cpks = opts[:primary_keys] = Array(primary_key)
           pkc = opts[:primary_key_column] ||= primary_key
           pkcs = opts[:primary_key_columns] ||= Array(pkc)
-          elk = opts.eager_loader_key
           raise(Error, "mismatched number of composite keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:dataset] ||= proc do
-            opts.associated_class.filter(Array(opts.qualified_key).zip(cpks.map{|k| send(k)}))
+            opts.associated_class.filter(opts.predicate_keys.zip(cpks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
-            h = eo[:key_hash][elk]
+            h = eo[:id_map]
             rows = eo[:rows]
             if one_to_one
               rows.each{|object| object.associations[name] = nil}
@@ -1276,7 +1295,7 @@ module Sequel
             end
             reciprocal = opts.reciprocal
             klass = opts.associated_class
-            filter_keys = opts.eager_loading_predicate_key
+            filter_keys = opts.predicate_key
             ds = model.eager_loading_dataset(opts, klass.filter(filter_keys=>h.keys), nil, eo[:associations], eo)
             case opts.eager_limit_strategy
             when :distinct_on
@@ -1323,7 +1342,7 @@ module Sequel
           graph_block = opts[: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(pkcs) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>join_type, :qualify=>:deep, :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][eo[:table_alias]] = opts.reciprocal
             ds
@@ -1341,7 +1360,7 @@ module Sequel
               association_module_private_def(opts._setter_method, opts) do |o|
                 up_ds = _apply_association_options(opts, opts.associated_class.filter(cks.zip(cpks.map{|k| send(k)})))
                 if o
-                  up_ds = up_ds.exclude(o.pk_hash)
+                  up_ds = up_ds.exclude(o.pk_hash) unless o.new?
                   cks.zip(cpks).each{|k, pk| o.send(:"#{k}=", send(pk))}
                 end
                 checked_transaction do
@@ -1802,8 +1821,7 @@ module Sequel
         # need to filter based on columns in associated tables, look at +eager_graph+
         # or join the tables you need to filter on manually. 
         #
-        # Each association's order, if defined, is respected. Eager also works
-        # on a limited dataset, but does not use any :limit options for associations.
+        # Each association's order, if defined, is respected.
         # If the association uses a block or has an :eager_block argument, it is used.
         def eager(*associations)
           opt = @opts[:eager]
@@ -1877,11 +1895,18 @@ module Sequel
         # model :: Current Model
         # ta :: table_alias used for the parent association
         # requirements :: an array, used as a stack for requirements
-        # r :: association reflection for the current association
+        # r :: association reflection for the current association, or an SQL::AliasedExpression
+        #      with the reflection as the expression and the alias base as the aliaz.
         # *associations :: any associations dependent on this one
         def eager_graph_association(ds, model, ta, requirements, r, *associations)
+          if r.is_a?(SQL::AliasedExpression)
+            alias_base = r.aliaz
+            r = r.expression
+          else
+            alias_base = r[:graph_alias_base]
+          end
           assoc_name = r[:name]
-          assoc_table_alias = ds.unused_table_alias(r[:graph_alias_base])
+          assoc_table_alias = ds.unused_table_alias(alias_base)
           loader = r[:eager_grapher]
           if !associations.empty?
             if associations.first.respond_to?(:call)
@@ -1919,11 +1944,11 @@ module Sequel
           return ds if associations.empty?
           associations.flatten.each do |association|
             ds = case association
-            when Symbol
-              ds.eager_graph_association(ds, model, ta, requirements, check_association(model, association))
+            when Symbol, SQL::AliasedExpression
+              ds.eager_graph_association(ds, model, ta, requirements, eager_graph_check_association(model, association))
             when Hash
               association.each do |assoc, assoc_assocs|
-                ds = ds.eager_graph_association(ds, model, ta, requirements, check_association(model, assoc), assoc_assocs)
+                ds = ds.eager_graph_association(ds, model, ta, requirements, eager_graph_check_association(model, assoc), assoc_assocs)
               end
               ds
             else raise(Sequel::Error, 'Associations must be in the form of a symbol or hash')
@@ -1931,7 +1956,7 @@ module Sequel
           end
           ds
         end
-      
+
         # Replace the array of plain hashes with an array of model objects will all eager_graphed
         # associations set in the associations cache for each object.
         def eager_graph_build_associations(hashes)
@@ -1990,6 +2015,16 @@ module Sequel
           reflection
         end
       
+        # 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)
+            SQL::AliasedExpression.new(check_association(model, association.expression), association.aliaz)
+          else
+            check_association(model, association)
+          end
+        end
+      
         # Eagerly load all specified associations 
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
@@ -2001,22 +2036,35 @@ module Sequel
           # Reflections for all associations to eager load
           reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
-          # Populate keys to monitor
-          reflections.each{|reflection| key_hash[reflection.eager_loader_key] ||= Hash.new{|h,k| h[k] = []}}
-          
-          # Associate each object with every key being monitored
-          a.each do |rec|
-            key_hash.each do |key, id_map|
-              case key
-              when Array
-                id_map[key.map{|k| rec[k]}] << rec if key.all?{|k| rec[k]}
-              when Symbol
-                id_map[rec[key]] << rec if rec[key]
+          # Populate the key_hash entry for each association being eagerly loaded
+          reflections.each do |r|
+            if key = r.eager_loader_key
+              # key_hash for this key has already been populated,
+              # skip populating again so that duplicate values
+              # aren't added.
+              unless id_map = key_hash[key]
+                id_map = key_hash[key] = Hash.new{|h,k| h[k] = []}
+
+                # Supporting both single (Symbol) and composite (Array) keys.
+                a.each do |rec|
+                  case key
+                  when Array
+                    if (k = key.map{|k2| rec.send(k2)}) && k.all?
+                      id_map[k] << rec
+                    end
+                  when Symbol
+                    if k = rec.send(key)
+                      id_map[k] << rec
+                    end
+                  else
+                    raise Error, "unhandled eager_loader_key #{key.inspect} for association #{r[:name]}"
+                  end
+                end
               end
+            else
+              id_map = nil
             end
-          end
           
-          reflections.each do |r|
             loader = r[:eager_loader]
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
@@ -2026,7 +2074,7 @@ module Sequel
               eager_block, associations = pr_assoc
             end
             if loader.arity == 1
-              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block)
+              loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map)
             else
               loader.call(key_hash, a, associations)
             end
@@ -2041,12 +2089,17 @@ module Sequel
 
         # 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, lks, rks = ref.values_at(:left_primary_key_columns, :left_keys, :right_keys)
           jt = ref.join_table_alias
           lpks = lpks.first if lpks.length == 1
           lpks = ref.qualify(model.table_name, lpks)
-          meths = ref.right_primary_keys
-          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+
+          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(jt, rks), meths, obj)
           if exp == SQL::Constants::FALSE
             association_filter_handle_inversion(op, exp, Array(lpks))
@@ -2057,17 +2110,23 @@ module Sequel
 
         # 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.qualify(model.table_name, ref[:keys])
-          meths = ref.primary_keys
-          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+          keys = ref.qualify(model.table_name, ref[:key_columns])
+          meths = if obj.is_a?(Sequel::Dataset)
+            ref.qualify(obj.model.table_name, ref.primary_keys)
+          else
+            ref.primary_key_methods
+          end
           association_filter_handle_inversion(op, association_filter_key_expression(keys, meths, 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.qualify(model.table_name, ref[:primary_keys])
-          meths = ref[:keys]
-          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+          keys = ref.qualify(model.table_name, ref[:primary_key_columns])
+          meths = if obj.is_a?(Sequel::Dataset)
+            ref.qualify(obj.model.table_name, ref[:keys])
+          else
+            ref[:key_methods]
+          end
           association_filter_handle_inversion(op, association_filter_key_expression(keys, meths, obj), keys)
         end
         alias one_to_one_association_filter_expression one_to_many_association_filter_expression