sequel 1.5.1 → 2.0.0

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 2.0.0 (2008-06-01)
+
+* Comprehensive update of all documentation (jeremyevans)
+
+* Remove methods deprecated in 1.5.0 (jeremyevans)
+
+* Add typecasting on attribute assignment to Sequel::Model objects, optional but enabled by default (jeremyevans)
+
+* Returning false in one of the before_ hooks now causes the appropriate method(s) to immediately return false (jeremyevans)
+
+* Add remove_all_* association method for *_to_many associations, which removes the association with all currently associated objects (jeremyevans)
+
+* Add Model.lazy_load_schema=, when set to true, it loads the schema on first instantiation (jeremyevans)
+
+* Add before_validation and after_validation hooks, called whenever the model is validated (jeremyevans)
+
+* Add Model.default_foreign_key, a private class method that allows changing the default foreign key that Sequel will use in associations (jeremyevans)
+
+* Cache negative lookup when eagerly loading many_to_one associations (jeremyevans)
+
+* Make all associations support the :select option, not just many_to_many (jeremyevans)
+
+* Allow the use of blocks when eager loading, and add the :eager_block and :allow_eager association options for configuration (jeremyevans)
+
+* Add the :graph_join_type, :graph_conditions, and :graph_join_table_conditions association options, used when eager graphing (jeremyevans)
+
+* Add AssociationReflection class (subclass of Hash), to make calling a couple of private Model methods unnecessary (jeremyevans)
+
+* Change hook methods so that if a tag/method is specified it overwrites an existing hook block with the same tag/method (jeremyevans)
+
 === 1.5.1 (2008-04-30)
 
 * Fix Dataset#eager_graph when not all objects have associated objects (jeremyevans)

data/README

@@ -16,18 +16,13 @@ You can, however, explicitly set the table name or even the dataset used:
 
   class Post < Sequel::Model(:my_posts)
   end
-
   # or:
-
   Post.set_dataset :my_posts
-
   # or:
-
   Post.set_dataset DB[:my_posts].where(:category => 'ruby')
 
 === Resources
 
-* {Project page}[http://code.google.com/p/ruby-sequel/]
 * {Source code}[http://github.com/jeremyevans/sequel]
 * {Bug tracking}[http://code.google.com/p/ruby-sequel/issues/list]
 * {Google group}[http://groups.google.com/group/sequel-talk]
@@ -70,7 +65,7 @@ You can also define a model class that does not have a primary key, but then you
 A model instance can also be fetched by specifying a condition:
 
   post = Post[:title => 'hello world']
-  post = Post.find{:num_comments < 10}
+  post = Post.find(:num_comments < 10)
 
 === Iterating over records
 
@@ -80,8 +75,8 @@ A model class lets you iterate over specific records by acting as a proxy to the
 
 You can also manipulate the records in the dataset:
 
-  Post.filter{:num_comments < 7}.delete
-  Post.filter{:title =~ /ruby/}.update(:category => 'ruby')
+  Post.filter(:num_comments < 7).delete
+  Post.filter(:title.like(/ruby/)).update(:category => 'ruby')
 
 === Accessing record values
 
@@ -126,7 +121,7 @@ You can also supply a block to Model.new and Model.create:
 
 === Hooks
 
-You can execute custom code when creating, updating, or deleting records by using hooks. The before_create and after_create hooks wrap record creation. The before_update and after_update wrap record updating. The before_save and after_save wrap record creation and updating. The before_destroy and after_destroy wrap destruction.
+You can execute custom code when creating, updating, or deleting records by using hooks. The before_create and after_create hooks wrap record creation. The before_update and after_update wrap record updating. The before_save and after_save wrap record creation and updating. The before_destroy and after_destroy wrap destruction. The before_validation and after_validation hooks wrap validation.
 
 Hooks are defined by supplying a block:
 
@@ -174,7 +169,7 @@ You can also use the ActiveRecord names for these associations:
     has_and_belongs_to_many :tags
   end
 
-many_to_one/belongs_to creates a getter and setter for each model object:
+many_to_one creates a getter and setter for each model object:
 
   class Post < Sequel::Model
     many_to_one :author
@@ -184,7 +179,7 @@ many_to_one/belongs_to creates a getter and setter for each model object:
   post.author = Author[:name => 'Sharon']
   post.author
 
-one_to_many/has_many and many_to_many/has_and_belongs_to_many create a getter method, a method for adding an object to the association, and a method for removing an object from the association:
+one_to_many and many_to_many create a getter method, a method for adding an object to the association, a method for removing an object from the association, and a method for removing all associated objected from the association:
 
   class Post < Sequel::Model
     one_to_many :comments
@@ -196,9 +191,11 @@ one_to_many/has_many and many_to_many/has_and_belongs_to_many create a getter me
   comment = Comment.create(:text=>'hi')
   post.add_comment(comment)
   post.remove_comment(comment)
+  post.remove_all_comments
   tag = Tag.create(:tag=>'interesting')
   post.add_tag(tag)
   post.remove_tag(tag)
+  post.remove_all_tags
 
 === Eager Loading
 
@@ -229,7 +226,7 @@ Associations can be eagerly loaded via .eager and the :eager association option.
   Post.eager(:person).all
 
   # eager is a dataset method, so it works with filters/orders/limits/etc.
-  Post.filter("topic > 'M'").order(:date).limit(5).eager(:person).all
+  Post.filter(:topic > 'M').order(:date).limit(5).eager(:person).all
   
   person = Person.first
   # Eager loading via :eager (will eagerly load the tags for this person's posts)
@@ -273,7 +270,7 @@ The obvious way to add table-wide logic is to define class methods to the model
 
   class Post < Sequel::Model
     def self.posts_with_few_comments
-      filter{:num_comments < 30}
+      filter(:num_comments < 30)
     end
 
     def self.clean_posts_with_few_comments
@@ -285,7 +282,7 @@ You can also implement table-wide logic by defining methods on the dataset:
 
   class Post < Sequel::Model
     def_dataset_method(:posts_with_few_comments) do
-      filter{:num_comments < 30}
+      filter(:num_comments < 30)
     end
 
     def_dataset_method(:clean_posts_with_few_comments) do
@@ -300,7 +297,7 @@ This is the recommended way of implementing table-wide operations, and allows yo
 Sequel models also provide a short hand notation for filters:
 
   class Post < Sequel::Model
-    subset(:posts_with_few_comments){:num_comments < 30}
+    subset(:posts_with_few_comments, :num_comments < 30)
     subset :invisible, :visible => false
   end
 

data/Rakefile

@@ -9,20 +9,19 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel"
-VERS = "1.5.1"
-SEQUEL_CORE_VERS= "1.5.1"
-CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
-RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source"]
+VERS = "2.0.0"
+SEQUEL_CORE_VERS= "2.0.0"
+CLEAN.include ["**/.*.sw?", "pkg", ".config", "rdoc", "coverage"]
+RDOC_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', \
+  'Sequel: The Database Toolkit for Ruby: Model Classes', '--main', 'README']
 
 ##############################################################################
 # RDoc
 ##############################################################################
 Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.main = "README"
-  rdoc.title = "Sequel: The Database Toolkit for Ruby: Model Classes"
-  rdoc.rdoc_files.add ["README", "COPYING", "lib/**/*.rb"]
+  rdoc.rdoc_files.add ["README", "COPYING", "doc/*.rdoc", "lib/**/*.rb"]
 end
 
 ##############################################################################
@@ -37,7 +36,7 @@ spec = Gem::Specification.new do |s|
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"]
   s.rdoc_options += RDOC_OPTS + ["--exclude", "^(examples|extras)\/"]
   s.summary = "The Database Toolkit for Ruby: Model Classes"
   s.description = s.summary
@@ -45,18 +44,8 @@ spec = Gem::Specification.new do |s|
   s.email = "code@jeremyevans.net"
   s.homepage = "http://sequel.rubyforge.org"
   s.required_ruby_version = ">= 1.8.4"
-
-  case RUBY_PLATFORM
-  when /java/
-    s.platform = "jruby"
-  else
-    s.platform = Gem::Platform::RUBY
-  end
-
   s.add_dependency("sequel_core", "= #{SEQUEL_CORE_VERS}")
-  
   s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
-
   s.require_path = "lib"
 end
 
@@ -135,7 +124,7 @@ STATS_DIRECTORIES = [
 
 desc "Report code statistics (KLOCs, etc) from the application"
 task :stats do
-  require "extra/stats"
+  require "../extra/stats"
   verbose = true
   CodeStatistics.new(*STATS_DIRECTORIES).to_s
 end

data/lib/sequel_model.rb

@@ -1,82 +1,57 @@
 require 'sequel_core'
+%w"inflector base hooks record schema association_reflection 
+  associations caching plugins validations eager_loading".each do |f|
+  require "sequel_model/#{f}"
+end
 
 module Sequel
-  class Model
-    alias_method :model, :class
+  # Holds the nameless subclasses that are created with
+  # Sequel::Model(), necessary for reopening subclasses with the
+  # Sequel::Model() superclass specified.
+  @models = {}
+
+  # Lets you create a Model subclass with its dataset already set.
+  # source can be an existing dataset or a symbol (in which case
+  # it will create a dataset using the default database with 
+  # source as the table name.
+  #
+  # Example:
+  #   class Comment < Sequel::Model(:something)
+  #     table_name # => :something
+  #   end
+  def self.Model(source)
+    return @models[source] if @models[source]
+    klass = Class.new(Model)
+    klass.set_dataset(source.is_a?(Dataset) ? source : Model.db[source])
+    @models[source] = klass
   end
-end
 
-files = %w[
-  inflector inflections base hooks record schema associations 
-  caching plugins validations eager_loading deprecated
-]
-dir = File.join(File.dirname(__FILE__), "sequel_model")
-files.each {|f| require(File.join(dir, f))}
-
-module Sequel
+  # Model has some methods that are added via metaprogramming:
+  #
+  # * All of the methods in DATASET_METHODS have class methods created that call
+  #   the Model's dataset with the method of the same name with the given
+  #   arguments.
+  # * All of the methods in HOOKS have class methods created that accept
+  #   either a method name symbol or an optional tag and a block.  These
+  #   methods run the code as a callback at the specified time.  For example:
+  #
+  #     Model.before_save :do_something
+  #     Model.before_save(:do_something_else){ self.something_else = 42}
+  #     object = Model.new
+  #     object.save
+  #
+  #   Would run the object's :do_something method following by the code
+  #   block related to :do_something_else.  Note that if you specify a
+  #   block, a tag is optional.  If the tag is not nil, it will overwrite
+  #   a previous block with the same tag.  This allows hooks to work with
+  #   systems that reload code.
+  # * All of the methods in HOOKS also create instance methods, but you
+  #   should not override these instance methods.
+  # * The following instance_methods all call the class method of the same
+  #   name: columns, dataset, db, primary_key, str_columns.
   class Model
     extend Enumerable
     extend Associations
-    # Returns a string representation of the model instance including
-    # the class name and values.
-    def inspect
-      "#<%s @values=%s>" % [self.class.name, @values.inspect]
-    end
-    
-    # Defines a method that returns a filtered dataset.
-    def self.subset(name, *args, &block)
-      def_dataset_method(name){filter(*args, &block)}
-    end
-    
-    # Finds a single record according to the supplied filter, e.g.:
-    #
-    #   Ticket.find :author => 'Sharon' # => record
-    #   Ticket.find {:price == 17} # => Dataset
-    #
-    def self.find(*args, &block)
-      dataset.filter(*args, &block).first
-    end
-    
-    # TODO: doc
-    def self.[](*args)
-      args = args.first if (args.size == 1)
-      if args === true || args === false
-        raise Error::InvalidFilter, "Did you mean to supply a hash?"
-      end
-      dataset[(Hash === args) ? args : primary_key_hash(args)]
-    end
-    
-    # TODO: doc
-    def self.fetch(*args)
-      db.fetch(*args).set_model(self)
-    end
-
-    # Like find but invokes create with given conditions when record does not
-    # exists.
-    def self.find_or_create(cond)
-      find(cond) || create(cond)
-    end
-
-    # Deletes all records in the model's table.
-    def self.delete_all
-      dataset.delete
-    end
-
-    # Like delete_all, but invokes before_destroy and after_destroy hooks if used.
-    def self.destroy_all
-      dataset.destroy
-    end
-
-    # Add dataset methods via metaprogramming
-    DATASET_METHODS = %w'all avg count delete distinct eager eager_graph each each_page 
-       empty? except exclude filter first from_self full_outer_join graph 
-       group group_and_count group_by having import inner_join insert 
-       insert_multiple intersect interval invert_order join join_table last 
-       left_outer_join limit multi_insert naked order order_by order_more 
-       paginate print query range reverse_order right_outer_join select 
-       select_all select_more set set_graph_aliases single_value size to_csv 
-       transform union uniq unordered update where'
-
-    def_dataset_method *DATASET_METHODS
+    include Validation
   end
 end

data/lib/sequel_model/association_reflection.rb

@@ -0,0 +1,59 @@
+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
+      # be instantiated by the user.
+      class AssociationReflection < Hash
+        RECIPROCAL_ASSOCIATIONS = {:many_to_one=>:one_to_many, :one_to_many=>:many_to_one, :many_to_many=>:many_to_many}
+  
+        # The class associated to the current model class via this association
+        def associated_class
+          self[:class] ||= self[:class_name].constantize
+        end
+  
+        # The associated class's primary key (used for caching)
+        def associated_primary_key
+         self[:associated_primary_key] ||= associated_class.primary_key
+        end
+  
+        # Returns/sets the reciprocal association variable, if one exists
+        def reciprocal
+          return self[:reciprocal] if include?(:reciprocal)
+          reciprocal_type = RECIPROCAL_ASSOCIATIONS[self[:type]]
+          if reciprocal_type == :many_to_many
+            left_key = self[:left_key]
+            right_key = self[:right_key]
+            join_table = self[:join_table]
+            associated_class.all_association_reflections.each do |assoc_reflect|
+              if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_key] == right_key \
+                 && assoc_reflect[:right_key] == left_key && assoc_reflect[:join_table] == join_table
+                return self[:reciprocal] = association_ivar(assoc_reflect[:name])
+              end
+            end
+          else
+            key = self[:key]
+            associated_class.all_association_reflections.each do |assoc_reflect|
+              if assoc_reflect[:type] == reciprocal_type && assoc_reflect[:key] == key
+                return self[:reciprocal] = association_ivar(assoc_reflect[:name])
+              end
+            end
+          end
+          self[:reciprocal] = nil
+        end
+
+        # The columns to select when loading the association
+        def select
+         self[:select] ||= associated_class.table_name.*
+        end
+  
+        private
+
+        # Name symbol of association instance variable
+        def association_ivar(name)
+          :"@#{name}"
+        end
+      end
+    end
+  end
+end

data/lib/sequel_model/associations.rb

@@ -19,6 +19,7 @@
 #   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
 #
 # By default the classes for the associations are inferred from the association
 # name, so for example the Project#portfolio will return an instance of 
@@ -27,9 +28,9 @@
 #
 # Association definitions are also reflected by the class, e.g.:
 #
-#   >> Project.associations
+#   Project.associations
 #   => [:portfolio, :milestones]
-#   >> Project.association_reflection(:portfolio)
+#   Project.association_reflection(:portfolio)
 #   => {:type => :many_to_one, :name => :portfolio, :class_name => "Portfolio"}
 #
 # Associations can be defined by either using the associate method, or by
@@ -42,9 +43,7 @@
 #   one_to_many :attributes
 #   has_many :attributes
 module Sequel::Model::Associations
-  RECIPROCAL_ASSOCIATIONS = {:many_to_one=>:one_to_many, :one_to_many=>:many_to_one, :many_to_many=>:many_to_many}
-
-  # Array of all association reflections
+  # Array of all association reflections for this model class
   def all_association_reflections
     association_reflections.values
   end
@@ -71,6 +70,8 @@ module Sequel::Model::Associations
   #
   # The following options can be supplied:
   # * *ALL types*:
+  #   - :allow_eager - If set to false, you cannot load the association eagerly
+  #     via eager or eager_graph
   #   - :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)
@@ -78,13 +79,25 @@ module Sequel::Model::Associations
   #     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
+  #   - :graph_join_type - The type of SQL join to use when eagerly loading the association via
+  #     eager_graph
+  #   - :order - the column(s) by which to order the association dataset.  Can be a
+  #     singular column or an array.
   #   - :reciprocal - the symbol name of the instance variable of the reciprocal association,
   #     if it exists.  By default, sequel will try to determine it by looking at the
   #     associated model's assocations for a association that matches
   #     the current association's key(s).  Set to nil to not use a reciprocal.
-  # * :one_to_many/:many_to_many:
-  #   - :order - the column(s) by which to order the association dataset.  Can be a
-  #     singular column or an array.
+  #   - :select - the attributes to select.  Defaults to the associated class's
+  #     table_name.*, which means it doesn't include the attributes from the
+  #     join table in a many_to_many association.  If you want to include the join table attributes, you can
+  #     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.
   # * :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".
@@ -98,27 +111,21 @@ module Sequel::Model::Associations
   #     of current model and name of associated model, pluralized,
   #     underscored, sorted, and joined with '_'.
   #   - :left_key - foreign key in join table that points to current model's
-  #     primary key, as a symbol.
+  #     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.
-  #   - :select - the attributes to select.  Defaults to the associated class's
-  #     table_name.*, which means it doesn't include the attributes from the
-  #     join table.  If you want to include the join table attributes, you can
-  #     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.
+  #     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
   def associate(type, name, opts = {}, &block)
     # check arguments
     raise ArgumentError unless [:many_to_one, :one_to_many, :many_to_many].include?(type) && Symbol === name
 
     # merge early so we don't modify opts
-    opts = opts.merge(:type => type, :name => name, :block => block, :cache => true)
-
-    # deprecation
-    if opts[:from]
-      Sequel::Deprecation.deprecate("The :from option to Sequel::Model.associate is deprecated and will be removed in Sequel 2.0.  Use the :class option.")
-      opts[:class] = opts[:from]
-    end
+    opts = opts.merge(:type => type, :name => name, :block => block, :cache => true, :model => self)
+    opts = AssociationReflection.new.merge!(opts)
+    opts[:eager_block] = block unless opts.include?(:eager_block)
+    opts[:graph_join_type] ||= :left_outer
+    opts[:graph_conditions] = opts[:graph_conditions] ? opts[:graph_conditions].to_a : []
 
     # find class
     case opts[:class]
@@ -164,10 +171,6 @@ module Sequel::Model::Associations
   alias_method :has_and_belongs_to_many, :many_to_many
   
   private
-  # The class related to the given association reflection
-  def associated_class(opts)
-    opts[:class] ||= opts[:class_name].constantize
-  end
 
   # Name symbol for add association method
   def association_add_method_name(name)
@@ -179,7 +182,12 @@ module Sequel::Model::Associations
     :"@#{name}"
   end
   
-  # Name symbol for remove_method_name
+  # 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
@@ -190,7 +198,7 @@ module Sequel::Model::Associations
     @association_reflections ||= {}
   end
   
-  # Defines an association
+  # 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"
@@ -199,7 +207,7 @@ module Sequel::Model::Associations
     
     # define a method returning the association dataset (with optional order)
     if order = opts[:order]
-      class_def(dataset_method) {instance_eval(&block).order(order)}
+      class_def(dataset_method) {instance_eval(&block).order(*order)}
     else
       class_def(dataset_method, &block)
     end
@@ -225,83 +233,88 @@ module Sequel::Model::Associations
         end
         objs = ds.all
         # Only one_to_many associations should set the reciprocal object
-        if (opts[:type] == :one_to_many) && (reciprocal = model.send(:reciprocal_association, opts))
+        if (opts[:type] == :one_to_many) && (reciprocal = opts.reciprocal)
           objs.each{|o| o.instance_variable_set(reciprocal, self)}
         end
         instance_variable_set(ivar, objs)
       end
     end
   end
-  
-  # Defines an association getter method, caching the block result in an 
-  # instance variable. The defined method takes an optional reload parameter
-  # that can be set to true in order to bypass the cache.
-  def def_association_getter(name, &block)
-    ivar = association_ivar(name)
-    class_def(name) do |*reload|
-      if !reload[0] && obj = instance_variable_get(ivar)
-        obj == :null ? nil : obj
-      else
-        obj = instance_eval(&block)
-        instance_variable_set(ivar, obj || :null)
-        obj
-      end
-    end
-  end
 
   # Adds many_to_many association instance methods
   def def_many_to_many(name, opts)
-    assoc_class = method(:associated_class) # late binding of association dataset
-    recip_assoc = method(:reciprocal_association) # late binding of the reciprocal association
     ivar = association_ivar(name)
     left = (opts[:left_key] ||= default_remote_key)
-    right = (opts[:right_key] ||= :"#{name.to_s.singularize}_id")
+    right = (opts[:right_key] ||= default_foreign_key(opts))
     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]}"
+    opts[:graph_join_table_conditions] = opts[:graph_join_table_conditions] ? opts[:graph_join_table_conditions].to_a : []
     database = db
     
     def_association_dataset_methods(name, opts) do
-      klass = assoc_class[opts]
-      key = (opts[:right_primary_key] ||= :"#{klass.table_name}__#{klass.primary_key}")
-      selection = (opts[:select] ||= klass.table_name.*)
-      klass.select(selection).inner_join(join_table, right => key, left => pk)
+      opts.associated_class.select(*opts.select).inner_join(join_table, [[right, opts.associated_primary_key], [left, pk]])
     end
 
     class_def(association_add_method_name(name)) do |o|
-      database[join_table].insert(left => pk, right => o.pk)
+      database[join_table].insert(left=>pk, right=>o.pk)
       if arr = instance_variable_get(ivar)
         arr.push(o)
       end
-      if (reciprocal = recip_assoc[opts]) && (list = o.instance_variable_get(reciprocal)) \
+      if (reciprocal = opts.reciprocal) && (list = o.instance_variable_get(reciprocal)) \
          && !(list.include?(self))
         list.push(self)
       end
       o
     end
     class_def(association_remove_method_name(name)) do |o|
-      database[join_table].filter(left => pk, right => o.pk).delete
+      database[join_table].filter([[left, pk], [right, o.pk]]).delete
       if arr = instance_variable_get(ivar)
         arr.delete(o)
       end
-      if (reciprocal = recip_assoc[opts]) && (list = o.instance_variable_get(reciprocal))
+      if (reciprocal = opts.reciprocal) && (list = o.instance_variable_get(reciprocal))
         list.delete(self)
       end
       o
     end
+    class_def(association_remove_all_method_name(name)) do
+      database[join_table].filter(left=>pk).delete
+      if arr = instance_variable_get(ivar)
+        reciprocal = opts.reciprocal
+        ret = arr.dup
+        arr.each do |o|
+          if reciprocal && (list = o.instance_variable_get(reciprocal))
+            list.delete(self)
+          end
+        end
+      end
+      instance_variable_set(ivar, [])
+      ret
+    end
   end
   
   # Adds many_to_one association instance methods
   def def_many_to_one(name, opts)
-    assoc_class = method(:associated_class) # late binding of association dataset
-    recip_assoc = method(:reciprocal_association) # late binding of the reciprocal association
     ivar = association_ivar(name)
     
-    key = (opts[:key] ||= :"#{name}_id")
+    key = (opts[:key] ||= default_foreign_key(opts))
     opts[:class_name] ||= name.to_s.camelize
     
-    def_association_getter(name) {(fk = send(key)) ? assoc_class[opts][fk] : nil}
+    class_def(name) do |*reload|
+      if !reload[0] && obj = instance_variable_get(ivar)
+        obj == :null ? nil : obj
+      else
+        obj = if fk = send(key)
+          opts.associated_class.select(*opts.select).filter(opts.associated_primary_key=>fk).first
+        end
+        instance_variable_set(ivar, obj || :null)
+        obj
+      end
+    end
+
     class_def(:"#{name}=") do |o|
-      old_val = instance_variable_get(ivar) if reciprocal = recip_assoc[opts]
+      old_val = instance_variable_get(ivar) if reciprocal = opts.reciprocal
       instance_variable_set(ivar, o)
       send(:"#{key}=", (o.pk if o))
       if reciprocal && (old_val != o)
@@ -318,13 +331,11 @@ module Sequel::Model::Associations
   
   # Adds one_to_many association instance methods
   def def_one_to_many(name, opts)
-    assoc_class = method(:associated_class) # late binding of association dataset
-    recip_assoc = method(:reciprocal_association) # late binding of the reciprocal association
     ivar = association_ivar(name)
     key = (opts[:key] ||= default_remote_key)
     opts[:class_name] ||= name.to_s.singularize.camelize
     
-    def_association_dataset_methods(name, opts) {assoc_class[opts].filter(key => pk)}
+    def_association_dataset_methods(name, opts) {opts.associated_class.select(*opts.select).filter(key => pk)}
     
     class_def(association_add_method_name(name)) do |o|
       o.send(:"#{key}=", pk)
@@ -332,7 +343,7 @@ module Sequel::Model::Associations
       if arr = instance_variable_get(ivar)
         arr.push(o)
       end
-      if reciprocal = recip_assoc[opts]
+      if reciprocal = opts.reciprocal
         o.instance_variable_set(reciprocal, self)
       end
       o
@@ -343,46 +354,40 @@ module Sequel::Model::Associations
       if arr = instance_variable_get(ivar)
         arr.delete(o)
       end
-      if reciprocal = recip_assoc[opts]
+      if reciprocal = opts.reciprocal
         o.instance_variable_set(reciprocal, :null)
       end
       o
     end
+    class_def(association_remove_all_method_name(name)) do
+      opts.associated_class.filter(key=>pk).update(key=>nil)
+      if arr = instance_variable_get(ivar)
+        ret = arr.dup
+        if reciprocal = opts.reciprocal
+          arr.each{|o| o.instance_variable_set(reciprocal, :null)} 
+        end
+      end
+      instance_variable_set(ivar, [])
+      ret
+    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
   
-  # Name symbol for default foreign key
+  # 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"
   end
-
-  # Sets the reciprocal association variable in the reflection, if one exists
-  def reciprocal_association(reflection)
-    return reflection[:reciprocal] if reflection.include?(:reciprocal)
-    reciprocal_type = ::Sequel::Model::Associations::RECIPROCAL_ASSOCIATIONS[reflection[:type]]
-    if reciprocal_type == :many_to_many
-      left_key = reflection[:left_key]
-      right_key = reflection[:right_key]
-      join_table = reflection[:join_table]
-      associated_class(reflection).all_association_reflections.each do |assoc_reflect|
-        if assoc_reflect[:type] == :many_to_many && assoc_reflect[:left_key] == right_key \
-           && assoc_reflect[:right_key] == left_key && assoc_reflect[:join_table] == join_table
-          return reflection[:reciprocal] = association_ivar(assoc_reflect[:name]).to_s.freeze
-        end
-      end
-    else
-      key = reflection[:key]
-      associated_class(reflection).all_association_reflections.each do |assoc_reflect|
-        if assoc_reflect[:type] == reciprocal_type && assoc_reflect[:key] == key
-          return reflection[:reciprocal] = association_ivar(assoc_reflect[:name])
-        end
-      end
-    end
-    reflection[:reciprocal] = nil
-  end
 end