sequel 2.1.0 → 2.2.0

data/lib/sequel_model.rb

@@ -53,9 +53,14 @@ module Sequel
   #   cache_store, cache_ttl, dataset_methods, primary_key, restricted_columns,
   #   sti_dataset, and sti_key.  You should not usually need to
   #   access these directly.
-  # * The following class level attr_accessors are created: strict_param_setting
-  #   and typecast_on_assignment:
+  # * The following class level attr_accessors are created: raise_on_save_failure,
+  #   strict_param_setting, and typecast_on_assignment:
   #
+  #     # Don't raise an error if a validation attempt fails in
+  #     # save/create/save_changes/etc.
+  #     Model.raise_on_save_failure = false
+  #     Model.before_save{false}
+  #     Model.new.save # => nil
   #     # Don't raise errors in new/set/update/etc. if an attempt to
   #     # access a missing/restricted method occurs (just silently
   #     # skip it)

data/lib/sequel_model/association_reflection.rb

@@ -2,11 +2,47 @@ module Sequel
   class Model
     module Associations
       # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
-      # provides a few methods to reduce the amount of internal code duplication.  It should not
+      # provides methods to reduce internal code duplication.  It should not
       # be instantiated by the user.
       class AssociationReflection < Hash
+        ASSOCIATION_TYPES = [:many_to_one, :one_to_many, :many_to_many]
         RECIPROCAL_ASSOCIATIONS = {:many_to_one=>:one_to_many, :one_to_many=>:many_to_one, :many_to_many=>:many_to_many}
   
+        # Name symbol for _add_ internal association method
+        def _add_method
+          :"_add_#{self[:name].to_s.singularize}"
+        end
+      
+        # Name symbol for _dataset association method
+        def _dataset_method
+          :"_#{self[:name]}_dataset"
+        end
+      
+        # Name symbol for _remove_all internal association method
+        def _remove_all_method
+          :"_remove_all_#{self[:name]}"
+        end
+      
+        # Name symbol for _remove_ internal association method
+        def _remove_method
+          :"_remove_#{self[:name].to_s.singularize}"
+        end
+      
+        # Name symbol for setter association method
+        def _setter_method
+          :"_#{self[:name]}="
+        end
+      
+        # Name symbol for add_ association method
+        def add_method
+          :"add_#{self[:name].to_s.singularize}"
+        end
+      
+        # Name symbol for association method, the same as the name of the association.
+        def association_method
+          self[:name]
+        end
+      
         # The class associated to the current model class via this association
         def associated_class
           self[:class] ||= self[:class_name].constantize
@@ -17,6 +53,54 @@ module Sequel
          self[:associated_primary_key] ||= associated_class.primary_key
         end
   
+        # Name symbol for dataset association method
+        def dataset_method
+          :"#{self[:name]}_dataset"
+        end
+      
+        # Name symbol for _helper internal association method
+        def dataset_helper_method
+          :"_#{self[:name]}_dataset_helper"
+        end
+      
+        # Whether the dataset needs a primary key to function
+        def dataset_need_primary_key?
+          self[:type] != :many_to_one
+        end
+
+        # Name symbol for default join table
+        def default_join_table
+          ([self[:class_name].demodulize, self[:model].name.demodulize]. \
+            map{|i| i.pluralize.underscore}.sort.join('_')).to_sym
+        end
+      
+        # Default foreign key name symbol for key in associated table that points to
+        # current table's primary key.
+        def default_left_key
+          :"#{self[:model].name.demodulize.underscore}_id"
+        end
+
+        # Default foreign key name symbol for foreign key in current model's table that points to
+        # the given association's table's primary key.
+        def default_right_key
+          :"#{self[:type] == :many_to_one ? self[:name] : self[:name].to_s.singularize}_id"
+        end
+      
+        # Name symbol for _dataset association method
+        def eager_dataset_method
+          :"#{self[:name]}_eager_dataset"
+        end
+      
+        # Whether to eagerly graph a lazy dataset
+        def eager_graph_lazy_dataset?
+          self[:type] != :many_to_one or opts[:key]
+        end
+
+        # Whether the associated object needs a primary key to be added/removed
+        def need_associated_primary_key?
+          self[:type] == :many_to_many
+        end
+
         # Returns/sets the reciprocal association variable, if one exists
         def reciprocal
           return self[:reciprocal] if include?(:reciprocal)
@@ -42,9 +126,35 @@ module Sequel
           self[:reciprocal] = nil
         end
 
+        # Name symbol for remove_all_ association method
+        def remove_all_method
+          :"remove_all_#{self[:name]}"
+        end
+      
+        # Name symbol for remove_ association method
+        def remove_method
+          :"remove_#{self[:name].to_s.singularize}"
+        end
+      
         # The columns to select when loading the association
         def select
-         self[:select] ||= associated_class.table_name.*
+         return self[:select] if include?(:select)
+         self[:select] = self[:type] == :many_to_many ? associated_class.table_name.* : nil
+        end
+
+        # Whether to set the reciprocal to the current object when loading
+        def set_reciprocal_to_self?
+          self[:type] == :one_to_many
+        end
+
+        # Name symbol for setter association method
+        def setter_method
+          :"#{self[:name]}="
+        end
+
+        # Whether the association should return a single object or multiple objects.
+        def single_associated_object?
+          self[:type] == :many_to_one
         end
       end
     end

data/lib/sequel_model/associations.rb

@@ -11,15 +11,17 @@
 #   end
 # 
 # The project class now has the following instance methods:
-# * portfolio - Returns the associated portfolio
+# * portfolio - Returns the associated portfolio.
 # * portfolio=(obj) - Sets the associated portfolio to the object,
 #   but the change is not persisted until you save the record.
+# * portfolio_dataset - Returns a dataset that would return the associated
+#   portfolio, only useful in fairly specific circumstances.
 # * milestones - Returns an array of associated milestones
+# * add_milestone(obj) - Associates the passed milestone with this object.
+# * remove_milestone(obj) - Removes the association with the passed milestone.
+# * remove_all_milestones - Removes associations with all associated milestones.
 # * milestones_dataset - Returns a dataset that would return the associated
 #   milestones, allowing for further filtering/limiting/etc.
-# * add_milestone(obj) - Associates the passed milestone with this object
-# * remove_milestone(obj) - Removes the association with the passed milestone
-# * remove_all_milestones - Removes associations with all associated milestones
 #
 # If you want to override the behavior of the add_/remove_/remove_all_ methods,
 # there are private instance methods created that a prepended with an
@@ -61,18 +63,18 @@ module Sequel::Model::Associations
   #   associated model's primary key.  Each associated model object can
   #   be associated with more than one current model objects.  Each current
   #   model object can be associated with only one associated model object.
-  #   Similar to ActiveRecord/DataMapper's belongs_to.
+  #   Similar to ActiveRecord's belongs_to.
   # * :one_to_many - Foreign key in associated model's table points to this
   #   model's primary key.   Each current model object can be associated with
   #   more than one associated model objects.  Each associated model object
   #   can be associated with only one current model object.
-  #   Similar to ActiveRecord/DataMapper's has_many.
+  #   Similar to ActiveRecord's has_many.
   # * :many_to_many - A join table is used that has a foreign key that points
   #   to this model's primary key and a foreign key that points to the
   #   associated model's primary key.  Each current model object can be
   #   associated with many associated model objects, and each associated
   #   model object can be associated with many current model objects.
-  #   Similar to ActiveRecord/DataMapper's has_and_belongs_to_many.
+  #   Similar to ActiveRecord's has_and_belongs_to_many.
   #
   # A one to one relationship can be set up with a many_to_one association
   # on the table with the foreign key, and a one_to_many association with the
@@ -82,25 +84,55 @@ module Sequel::Model::Associations
   # 
   # The following options can be supplied:
   # * *ALL types*:
+  #   - :after_add - Symbol, Proc, or array of both/either specifying a callback to call
+  #     after a new item is added to the association.
+  #   - :after_load - Symbol, Proc, or array of both/either specifying a callback to call
+  #     after the associated record(s) have been retrieved from the database.  Not called
+  #     when eager loading (see the :eager_loader option to accomplish it when eager loading).
+  #   - :after_remove - Symbol, Proc, or array of both/either specifying a callback to call
+  #     after an item is removed from the association.
   #   - :allow_eager - If set to false, you cannot load the association eagerly
   #     via eager or eager_graph
+  #   - :before_add - Symbol, Proc, or array of both/either specifying a callback to call
+  #     before a new item is added to the association.
+  #   - :before_remove - Symbol, Proc, or array of both/either specifying a callback to call
+  #     before an item is removed from the association.
   #   - :class - The associated class or its name. If not
   #     given, uses the association's name, which is camelized (and
   #     singularized unless the type is :many_to_one)
-  #   - :eager - The associations to eagerly load when loading the associated object.
+  #   - :dataset - A proc that is instance_evaled to get the base dataset
+  #     to use for the _dataset method (before the other options are applied).
+  #   - :eager - The associations to eagerly load via EagerLoading#eager when loading the associated object(s).
   #     For many_to_one associations, this is ignored unless this association is
   #     being eagerly loaded, as it doesn't save queries unless multiple objects
   #     can be loaded at once.
   #   - :eager_block - If given, use the block instead of the default block when
   #     eagerly loading.  To not use a block when eager loading (when one is used normally),
   #     set to nil.
-  #   - :graph_conditions - The conditions to use on the SQL join when eagerly loading
-  #     the association via eager_graph
+  #   - :eager_graph - The associations to eagerly load via EagerLoading#eager_graph when loading the associated object(s).
+  #     For many_to_one associations, this is ignored unless this association is
+  #     being eagerly loaded, as it doesn't save queries unless multiple objects
+  #     can be loaded at once.
+  #   - :eager_loader - A proc to use to implement eager loading, overriding the default.  Takes three arguments,
+  #     a key hash (used solely to enhance performance), an array of records,
+  #     and a hash of dependent associations.  The associated records should
+  #     be queried from the database and the associations cache for each
+  #     record should be populated for this to work correctly.
+  #   - :extend - A module or array of modules to extend the dataset with.
+  #   - :graph_block - The block to pass to join_table when eagerly loading
+  #     the association via eager_graph.
+  #   - :graph_conditions - The additional conditions to use on the SQL join when eagerly loading
+  #     the association via eager_graph.  Should be a hash or an array of all two pairs.
   #   - :graph_join_type - The type of SQL join to use when eagerly loading the association via
-  #     eager_graph
+  #     eager_graph.  Defaults to :left_outer.
+  #   - :graph_only_conditions - The conditions to use on the SQL join when eagerly loading
+  #     the association via eager_graph, instead of the default conditions specified by the
+  #     foreign/primary keys.  This option causes the :graph_conditions option to be ignored.
   #   - :graph_select - A column or array of columns to select from the associated table
   #     when eagerly loading the association via eager_graph. Defaults to all
   #     columns in the associated table.
+  #   - :limit - Limit the number of records to the provided value.  Use
+  #     an array with two arguments for the value to specify a limit and offset.
   #   - :order - the column(s) by which to order the association dataset.  Can be a
   #     singular column or an array.
   #   - :read_only - Do not add a setter method (for many_to_one or one_to_many with :one_to_one),
@@ -115,9 +147,6 @@ module Sequel::Model::Associations
   #     use this option, but beware that the join table attributes can clash with
   #     attributes from the model table, so you should alias any attributes that have
   #     the same name in both the join table and the associated table.
-  # * :one_to_many, :many_to_many:
-  #   - :limit - Limit the number of records to the provided value.  Use
-  #     an array with two arguments for the value to specify a limit and offset.
   # * :many_to_one:
   #   - :key - foreign_key in current model's table that references
   #     associated model's primary key, as a symbol.  Defaults to :"#{name}_id".
@@ -142,11 +171,21 @@ module Sequel::Model::Associations
   #     primary key, as a symbol. Defaults to :"#{self.name.underscore}_id".
   #   - :right_key - foreign key in join table that points to associated
   #     model's primary key, as a symbol.  Defaults to Defaults to :"#{name.to_s.singularize}_id".
-  #   - :graph_join_table_conditions - The conditions to use on the SQL join for the join table when eagerly loading
-  #     the association via eager_graph
+  #   - :graph_join_table_block - The block to pass to join_table for
+  #     the join table when eagerly loading the association via eager_graph.
+  #   - :graph_join_table_conditions - The additional conditions to use on the SQL join for
+  #     the join table when eagerly loading the association via eager_graph. Should be a hash
+  #     or an array of all two pairs.
+  #   - :graph_join_type - The type of SQL join to use for the join table when eagerly
+  #     loading the association via eager_graph.  Defaults to the :graph_join_type option or
+  #     :left_outer.
+  #   - :graph_join_table_only_conditions - The conditions to use on the SQL join for the join
+  #     table when eagerly loading the association via eager_graph, instead of the default
+  #     conditions specified by the foreign/primary keys.  This option causes the 
+  #     :graph_join_table_conditions option to be ignored.
   def associate(type, name, opts = {}, &block)
-    # check arguments
-    raise ArgumentError unless [:many_to_one, :one_to_many, :many_to_many].include?(type) && Symbol === name
+    raise(Error, 'invalid association type') unless AssociationReflection::ASSOCIATION_TYPES.include?(type)
+    raise(Error, 'Model.associate name argument must be a symbol') unless Symbol === name
 
     # merge early so we don't modify opts
     opts = opts.merge(:type => type, :name => name, :block => block, :cache => true, :model => self)
@@ -155,6 +194,9 @@ module Sequel::Model::Associations
     opts[:graph_join_type] ||= :left_outer
     opts[:graph_conditions] = opts[:graph_conditions] ? opts[:graph_conditions].to_a : []
     opts[:graph_select] = Array(opts[:graph_select]) if opts[:graph_select]
+    [:before_add, :before_remove, :after_add, :after_remove, :after_load, :extend].each do |cb_type|
+      opts[cb_type] = Array(opts[cb_type])
+    end
 
     # find class
     case opts[:class]
@@ -165,7 +207,7 @@ module Sequel::Model::Associations
         opts[:class_name] ||= opts[:class].name
     end
 
-    send(:"def_#{type}", name, opts)
+    send(:"def_#{type}", opts)
 
     # don't add to association_reflections until we are sure there are no errors
     association_reflections[name] = opts
@@ -201,250 +243,170 @@ module Sequel::Model::Associations
   
   private
 
-  # Name symbol for add association method
-  def association_add_method_name(name)
-    :"add_#{name.to_s.singularize}"
-  end
-
-  # Name symbol for remove_all association method
-  def association_remove_all_method_name(name)
-    :"remove_all_#{name}"
-  end
-  
-  # Name symbol for remove association method
-  def association_remove_method_name(name)
-    :"remove_#{name.to_s.singularize}"
-  end
-  
   # Hash storing the association reflections.  Keys are association name
   # symbols, values are association reflection hashes.
   def association_reflections
     @association_reflections ||= {}
   end
   
-  # Adds association methods to the model for *_to_many associations.
-  def def_association_dataset_methods(name, opts, &block)
-    dataset_method = :"#{name}_dataset"
-    helper_method = :"#{name}_helper"
-    dataset_block = opts[:block]
-    order = opts[:order]
-    eager = opts[:eager]
-    limit = opts[:limit]
+  # Add the add_ instance method 
+  def def_add_method(opts)
+    class_def(opts.add_method){|o| add_associated_object(opts, o)}
+  end
 
+  # Adds association methods to the model for *_to_many associations.
+  def def_association_dataset_methods(opts)
     # If a block is given, define a helper method for it, because it takes
     # an argument.  This is unnecessary in Ruby 1.9, as that has instance_exec.
-    if dataset_block
-      class_def(helper_method, &dataset_block)
-      private helper_method
-    end
-    
-    # define a method returning the association dataset (with optional order)
-    class_def(dataset_method) do
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk
-      ds = instance_eval(&block).select(*opts.select)
-      ds = ds.order(*order) if order
-      ds = ds.limit(*limit) if limit
-      ds = ds.eager(eager) if eager
-      ds = send(helper_method, ds) if dataset_block
-      ds
-    end
-    
-    class_def(name) do |*reload|
-      if (assoc = @associations).include?(name) and !reload[0]
-        assoc[name]
-      else
-        objs = send(dataset_method).all
-        # Only one_to_many associations should set the reciprocal object
-        if (opts[:type] == :one_to_many) && (reciprocal = opts.reciprocal)
-          objs.each{|o| o.associations[reciprocal] = self}
-        end
-        assoc[name] = objs
-      end
+    if opts[:block]
+      class_def(opts.dataset_helper_method, &opts[:block])
+      private opts.dataset_helper_method
     end
+    class_def(opts._dataset_method, &opts[:dataset])
+    private opts._dataset_method
+    class_def(opts.dataset_method){_dataset(opts)}
+    class_def(opts.association_method){|*reload| load_associated_objects(opts, reload[0])}
   end
 
   # Adds many_to_many association instance methods
-  def def_many_to_many(name, opts)
-    left = (opts[:left_key] ||= default_remote_key)
-    right = (opts[:right_key] ||= default_foreign_key(opts))
+  def def_many_to_many(opts)
+    name = opts[:name]
+    model = self
+    left = (opts[:left_key] ||= opts.default_left_key)
+    right = (opts[:right_key] ||= opts.default_right_key)
     opts[:class_name] ||= name.to_s.singularize.camelize
-    join_table = (opts[:join_table] ||= default_join_table_name(opts))
-    opts[:left_key_alias] ||= :"x_foreign_key_x"
-    opts[:left_key_select] ||= :"#{join_table}__#{left}___#{opts[:left_key_alias]}"
+    join_table = (opts[:join_table] ||= opts.default_join_table)
+    left_key_alias = opts[:left_key_alias] ||= :x_foreign_key_x
+    left_key_select = opts[:left_key_select] ||= left.qualify(join_table).as(opts[:left_key_alias])
     opts[:graph_join_table_conditions] = opts[:graph_join_table_conditions] ? opts[:graph_join_table_conditions].to_a : []
+    opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
+    opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, [[right, opts.associated_primary_key], [left, pk]])}
     database = db
     
-    def_association_dataset_methods(name, opts) do
-      opts.associated_class.inner_join(join_table, [[right, opts.associated_primary_key], [left, pk]])
+    opts[:eager_loader] ||= proc do |key_hash, records, associations|
+      h = key_hash[model.primary_key]
+      records.each{|object| object.associations[name] = []}
+      model.eager_loading_dataset(opts, opts.associated_class.inner_join(join_table, [[right, opts.associated_primary_key], [left, h.keys]]), Array(opts.select) + Array(left_key_select), associations).all do |assoc_record|
+        next unless objects = h[assoc_record.values.delete(left_key_alias)]
+        objects.each{|object| object.associations[name].push(assoc_record)}
+      end
     end
+    
+    def_association_dataset_methods(opts)
 
     return if opts[:read_only]
 
-    add_meth = association_add_method_name(name)
-    internal_add_meth = :"_#{add_meth}"
-    remove_meth = association_remove_method_name(name)
-    internal_remove_meth = :"_#{remove_meth}"
-    remove_all_meth = association_remove_all_method_name(name)
-    internal_remove_all_meth = :"_#{remove_all_meth}"
-
-    class_def(internal_add_meth) do |o|
+    class_def(opts._add_method) do |o|
       database[join_table].insert(left=>pk, right=>o.pk)
     end
-    class_def(internal_remove_meth) do |o|
+    class_def(opts._remove_method) do |o|
       database[join_table].filter([[left, pk], [right, o.pk]]).delete
     end
-    class_def(internal_remove_all_meth) do
+    class_def(opts._remove_all_method) do
       database[join_table].filter(left=>pk).delete
     end
-    private internal_add_meth, internal_remove_meth, internal_remove_all_meth
+    private opts._add_method, opts._remove_method, opts._remove_all_method
 
-    class_def(add_meth) do |o|
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk && o.pk
-      send(internal_add_meth, o)
-      if (assoc = @associations).include?(name)
-        assoc[name].push(o)
-      end
-      if reciprocal = opts.reciprocal and array = o.associations[reciprocal] and !array.include?(self)
-        array.push(self)
-      end
-      o
-    end
-    class_def(remove_meth) do |o|
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk && o.pk
-      send(internal_remove_meth, o)
-      if (assoc = @associations).include?(name)
-        assoc[name].delete_if{|x| o === x}
-      end
-      if reciprocal = opts.reciprocal and array = o.associations[reciprocal]
-        array.delete_if{|x| self === x}
-      end
-      o
-    end
-    class_def(remove_all_meth) do
-      raise(Sequel::Error, 'model object does not have a primary key') unless pk
-      send(internal_remove_all_meth)
-      if (assoc = @associations).include?(name)
-        reciprocal = opts.reciprocal
-        arr = assoc[name]
-        ret = arr.dup
-        arr.each do |o|
-          if reciprocal and array = o.associations[reciprocal]
-            array.delete_if{|x| self === x}
-          end
-        end
-      end
-      assoc[name] = []
-      ret
-    end
+    def_add_method(opts)
+    def_remove_methods(opts)
   end
   
   # Adds many_to_one association instance methods
-  def def_many_to_one(name, opts)
-    key = (opts[:key] ||= default_foreign_key(opts))
+  def def_many_to_one(opts)
+    name = opts[:name]
+    model = self
+    opts[:key] = opts.default_right_key unless opts.include?(:key)
+    key = opts[:key]
     opts[:class_name] ||= name.to_s.camelize
-    
-    class_def(name) do |*reload|
-      if (assoc = @associations).include?(name) and !reload[0]
-        assoc[name]
-      else
-        obj = if fk = send(key)
-          opts.associated_class.select(*opts.select).filter(opts.associated_primary_key=>fk).first
+    opts[:dataset] ||= proc do
+      klass = opts.associated_class
+      klass.filter(opts.associated_primary_key.qualify(klass.table_name)=>send(key))
+    end
+    opts[:eager_loader] ||= proc do |key_hash, records, associations|
+      h = key_hash[key]
+      keys = h.keys
+      # Skip eager loading if no objects have a foreign key for this association
+      unless keys.empty?
+        # Default the cached association to nil, so any object that doesn't have it
+        # populated will have cached the negative lookup.
+        records.each{|object| object.associations[name] = nil}
+        model.eager_loading_dataset(opts, opts.associated_class.filter(opts.associated_primary_key.qualify(opts.associated_class.table_name)=>keys),  opts.select, associations).all do |assoc_record|
+          next unless objects = h[assoc_record.pk]
+          objects.each{|object| object.associations[name] = assoc_record}
         end
-        assoc[name] = obj
       end
     end
+
+    def_association_dataset_methods(opts)
+    
     return if opts[:read_only]
 
-    class_def(:"#{name}=") do |o|  
+    class_def(opts._setter_method){|o| send(:"#{key}=", (o.pk if o))}
+    private opts._setter_method
+
+    class_def(opts.setter_method) do |o|  
       raise(Sequel::Error, 'model object does not have a primary key') if o && !o.pk
-      reciprocal = opts.reciprocal
-      if (assoc = @associations).include?(name) and reciprocal
-        old_val = assoc[name]
-      end
-      assoc[name] = o
-      send(:"#{key}=", (o.pk if o))
-      if reciprocal and old_val != o
-        if old_val and array = old_val.associations[reciprocal]
-          array.delete_if{|x| self === x}
-        end
-        if o and array = o.associations[reciprocal] and !array.include?(self)
-          array.push(self) 
-        end
-      end
+      old_val = send(opts.association_method)
+      return o if old_val == o
+      return if old_val and run_association_callbacks(opts, :before_remove, old_val) == false
+      return if o and run_association_callbacks(opts, :before_add, o) == false
+      send(opts._setter_method, o)
+      @associations[name] = o
+      remove_reciprocal_object(opts, old_val) if old_val
+      add_reciprocal_object(opts, o) if o
+      run_association_callbacks(opts, :after_add, o) if o
+      run_association_callbacks(opts, :after_remove, old_val) if old_val
       o
     end
   end
   
   # Adds one_to_many association instance methods
-  def def_one_to_many(name, opts)
-    key = (opts[:key] ||= default_remote_key)
+  def def_one_to_many(opts)
+    name = opts[:name]
+    model = self
+    key = (opts[:key] ||= opts.default_left_key)
     opts[:class_name] ||= name.to_s.singularize.camelize
+    opts[:dataset] ||= proc do
+      klass = opts.associated_class
+      klass.filter(key.qualify(klass.table_name) => pk)
+    end
+    opts[:eager_loader] ||= proc do |key_hash, records, associations|
+      h = key_hash[model.primary_key]
+      records.each{|object| object.associations[name] = []}
+      reciprocal = opts.reciprocal
+      model.eager_loading_dataset(opts, opts.associated_class.filter(key.qualify(opts.associated_class.table_name)=>h.keys), opts.select, associations).all do |assoc_record|
+        next unless objects = h[assoc_record[key]]
+        objects.each do |object| 
+          object.associations[name].push(assoc_record)
+          assoc_record.associations[reciprocal] = object if reciprocal
+        end
+      end
+    end
     
-    def_association_dataset_methods(name, opts) {opts.associated_class.filter(key => pk)}
+    def_association_dataset_methods(opts)
     
     unless opts[:read_only]
-      add_meth = association_add_method_name(name)
-      internal_add_meth = :"_#{add_meth}"
-      class_def(internal_add_meth) do |o|
+      class_def(opts._add_method) do |o|
         o.send(:"#{key}=", pk)
         o.save || raise(Sequel::Error, "invalid associated object, cannot save")
       end
-      private internal_add_meth
+      private opts._add_method
+      def_add_method(opts)
 
-      class_def(add_meth) do |o|
-        raise(Sequel::Error, 'model object does not have a primary key') unless pk
-        send(internal_add_meth, o)
-        if (assoc = @associations).include?(name)
-          assoc[name].push(o)
-        end
-        if reciprocal = opts.reciprocal
-          o.associations[reciprocal] = self
-        end
-        o
-      end
       unless opts[:one_to_one]
-        remove_meth = association_remove_method_name(name)
-        internal_remove_meth = :"_#{remove_meth}"
-        remove_all_meth = association_remove_all_method_name(name)
-        internal_remove_all_meth = :"_#{remove_all_meth}"
-
-        class_def(internal_remove_meth) do |o|
+        class_def(opts._remove_method) do |o|
           o.send(:"#{key}=", nil)
           o.save || raise(Sequel::Error, "invalid associated object, cannot save")
         end
-        class_def(internal_remove_all_meth) do
+        class_def(opts._remove_all_method) do
           opts.associated_class.filter(key=>pk).update(key=>nil)
         end
-        private internal_remove_meth, internal_remove_all_meth
-
-        class_def(remove_meth) do |o|
-          raise(Sequel::Error, 'model object does not have a primary key') unless pk
-          send(internal_remove_meth, o)
-          if (assoc = @associations).include?(name)
-            assoc[name].delete_if{|x| o === x}
-          end
-          if reciprocal = opts.reciprocal
-            o.associations[reciprocal] = nil
-          end
-          o
-        end
-        class_def(remove_all_meth) do
-          raise(Sequel::Error, 'model object does not have a primary key') unless pk
-          send(internal_remove_all_meth)
-          if (assoc = @associations).include?(name)
-            arr = assoc[name]
-            ret = arr.dup
-            if reciprocal = opts.reciprocal
-              arr.each{|o| o.associations[reciprocal] = nil}
-            end
-          end
-          assoc[name] = []
-          ret
-        end
+        private opts._remove_method, opts._remove_all_method
+        def_remove_methods(opts)
       end
     end
     if opts[:one_to_one]
-      private name, :"#{name}_dataset"
+      private opts.association_method, opts.dataset_method
       n = name.to_s.singularize.to_sym
       raise(Sequel::Error, "one_to_many association names should still be plural even when using the :one_to_one option") if n == name
       class_def(n) do |*o|
@@ -453,11 +415,11 @@ module Sequel::Model::Associations
         objs.first
       end
       unless opts[:read_only]
-        private add_meth
+        private opts.add_method
         class_def(:"#{n}=") do |o|
           klass = opts.associated_class
           model.db.transaction do
-            send(add_meth, o)
+            send(opts.add_method, o)
             klass.filter(Sequel::SQL::BooleanExpression.new(:AND, {key=>pk}, ~{klass.primary_key=>o.pk}.sql_expr)).update(key=>nil)
           end
         end
@@ -465,22 +427,9 @@ module Sequel::Model::Associations
     end
   end
   
-  # Default foreign key name symbol for foreign key in current model's table that points to
-  # the given association's table's primary key.
-  def default_foreign_key(reflection)
-    name = reflection[:name]
-    :"#{reflection[:type] == :many_to_one ? name : name.to_s.singularize}_id"
-  end
-
-  # Name symbol for default join table
-  def default_join_table_name(opts)
-    ([opts[:class_name].demodulize, name.demodulize]. \
-      map{|i| i.pluralize.underscore}.sort.join('_')).to_sym
-  end
-  
-  # Default foreign key name symbol for key in associated table that points to
-  # current table's primary key.
-  def default_remote_key
-    :"#{name.demodulize.underscore}_id"
+  # Add the remove_ and remove_all instance methods
+  def def_remove_methods(opts)
+    class_def(opts.remove_method){|o| remove_associated_object(opts, o)}
+    class_def(opts.remove_all_method){remove_all_associated_objects(opts)}
   end
 end