sequel 4.26.0 → 5.37.0

data/lib/sequel/extensions/virtual_row_method_block.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+#
+# These modifies virtual row blocks so that you can pass a block
+# when calling a method to change the behavior.  It only exists
+# for backwards compatibility with previous Sequel versions, and
+# is not recommended for new applications.
+# 
+# To load the extension:
+#
+#   Sequel.extension :virtual_row_method_block
+
+#
+module Sequel
+  module SQL
+    class VirtualRow < BasicObject
+      include(Module.new do
+        # Handle blocks passed to methods and change the behavior.
+        def method_missing(m, *args, &block)
+          if block
+            if args.empty?
+              Function.new(m)
+            else
+              case args.shift
+              when :*
+                Function.new(m, *args).*
+              when :distinct
+                Function.new(m, *args).distinct
+              when :over
+                opts = args.shift || OPTS
+                f = Function.new(m, *::Kernel.Array(opts[:args]))
+                f = f.* if opts[:*]
+                f.over(opts)
+              else
+                Kernel.raise(Error, 'unsupported VirtualRow method argument used with block')
+              end
+            end
+          else
+            super
+          end
+        end
+      end)
+    end
+  end
+end

data/lib/sequel/model.rb

@@ -1,67 +1,13 @@
-require 'sequel/core'
+# frozen-string-literal: true
 
-module Sequel
-  # Lets you create a Model subclass with its dataset already set.
-  # +source+ should be an instance of one of the following classes:
-  #
-  # Database :: Sets the database for this model to +source+.
-  #             Generally only useful when subclassing directly
-  #             from the returned class, where the name of the
-  #             subclass sets the table name (which is combined
-  #             with the +Database+ in +source+ to create the
-  #             dataset to use) 
-  # Dataset :: Sets the dataset for this model to +source+. 
-  # other :: Sets the table name for this model to +source+. The
-  #          class will use the default database for model
-  #          classes in order to create the dataset.
-  #
-  # The purpose of this method is to set the dataset/database automatically
-  # for a model class, if the table name doesn't match the implicit
-  # name.  This is neater than using set_dataset inside the class,
-  # doesn't require a bogus query for the schema.
-  #
-  #   # Using a symbol
-  #   class Comment < Sequel::Model(:something)
-  #     table_name # => :something
-  #   end
-  #
-  #   # Using a dataset
-  #   class Comment < Sequel::Model(DB1[:something])
-  #     dataset # => DB1[:something]
-  #   end
-  #
-  #   # Using a database
-  #   class Comment < Sequel::Model(DB1)
-  #     dataset # => DB1[:comments]
-  #   end
-  def self.Model(source)
-    if cache_anonymous_models && (klass = Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source]})
-      return klass
-    end
-    klass = if source.is_a?(Database)
-      c = Class.new(Model)
-      c.db = source
-      c
-    else
-      Class.new(Model).set_dataset(source)
-    end
-    Model::ANONYMOUS_MODEL_CLASSES_MUTEX.synchronize{Model::ANONYMOUS_MODEL_CLASSES[source] = klass} if cache_anonymous_models
-    klass
-  end
-
-  @cache_anonymous_models = true
-
-  class << self
-    # Whether to cache the anonymous models created by Sequel::Model().  This is
-    # required for reloading them correctly (avoiding the superclass mismatch).  True
-    # by default for backwards compatibility.
-    attr_accessor :cache_anonymous_models
-  end
+require_relative 'core'
 
+module Sequel
   # <tt>Sequel::Model</tt> is an object relational mapper built on top of Sequel core.  Each
   # model class is backed by a dataset instance, and many dataset methods can be
   # called directly on the class.  Model datasets return rows as model instances,
-  # which have fairly standard ORM instance behavior.
+  # which are wrappers around the underlying hash that allow easily updating or
+  # deleting the individual row.
   #
   # <tt>Sequel::Model</tt> is built completely out of plugins.  Plugins can override any class,
   # instance, or dataset method defined by a previous plugin and call super to get the default
@@ -74,75 +20,30 @@ module Sequel
   class Model
     OPTS = Sequel::OPTS
 
-    # Map that stores model classes created with <tt>Sequel::Model()</tt>, to allow the reopening
-    # of classes when dealing with code reloading.
-    ANONYMOUS_MODEL_CLASSES = {}
-
-    # Mutex protecting access to ANONYMOUS_MODEL_CLASSES
-    ANONYMOUS_MODEL_CLASSES_MUTEX = Mutex.new
-
-    # Class methods added to model that call the method of the same name on the dataset
-    DATASET_METHODS = (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS +
-      [:each_server]) - [:and, :or, :[], :columns, :columns!, :delete, :update, :add_graph_aliases, :first, :first!]
-    
-    # Boolean settings that can be modified at the global, class, or instance level.
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
-      :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_after_commit_rollback, :use_transactions]
-
-    # Hooks that are called before an action.  Can return false to not do the action.  When
-    # overriding these, it is recommended to call +super+ as the last line of your method,
-    # so later hooks are called before earlier hooks.
-    BEFORE_HOOKS = [:before_create, :before_update, :before_save, :before_destroy, :before_validation]
-
-    # Hooks that are called after an action.  When overriding these, it is recommended to call
-    # +super+ on the first line of your method, so later hooks are called after earlier hooks.
-    AFTER_HOOKS = [:after_create, :after_update, :after_save, :after_destroy,
-      :after_validation, :after_commit, :after_rollback, :after_destroy_commit, :after_destroy_rollback]
-
-    # Hooks that are called around an action.  If overridden, these methods must call super
-    # exactly once if the behavior they wrap is desired.  The can be used to rescue exceptions
-    # raised by the code they wrap or ensure that some behavior is executed no matter what.
-    AROUND_HOOKS = [:around_create, :around_update, :around_save, :around_destroy, :around_validation]
-
-    # Empty instance methods to create that the user can override to get hook/callback behavior.
+    # Empty instance methods to create that the user can override.
     # Just like any other method defined by Sequel, if you override one of these, you should
-    # call +super+ to get the default behavior (while empty by default, they can also be defined
+    # call +super+ to get the default behavior (while empty by default, they are often overridden
     # by plugins).  See the {"Model Hooks" guide}[rdoc-ref:doc/model_hooks.rdoc] for
     # more detail on hooks.
-    HOOKS = BEFORE_HOOKS + AFTER_HOOKS
-
-    # Class instance variables that are inherited in subclasses.  If the value is <tt>:dup</tt>, dup is called
-    # on the superclass's instance variable when creating the instance variable in the subclass.
-    # If the value is +nil+, the superclass's instance variable is used directly in the subclass.
-    INHERITED_INSTANCE_VARIABLES = {:@allowed_columns=>:dup,
-      :@dataset_method_modules=>:dup, :@primary_key=>nil, :@use_transactions=>nil,
-      :@raise_on_save_failure=>nil, :@require_modification=>nil, 
-      :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
-      :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
-      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
-      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
-      :@use_after_commit_rollback=>nil, :@fast_pk_lookup_sql=>nil,
-      :@fast_instance_delete_sql=>nil, :@finders=>:dup, :@finder_loaders=>:dup,
-      :@db=>nil, :@default_set_fields_options=>:dup}
-
-    # Regular expression that determines if a method name is normal in the sense that
-    # it could be used literally in ruby code without using send.  Used to
-    # avoid problems when using eval with a string to define methods.
-    NORMAL_METHOD_NAME_REGEXP = /\A[A-Za-z_][A-Za-z0-9_]*\z/
-
-    # Regular expression that determines if the method is a valid setter name
-    # (i.e. it ends with =).
-    SETTER_METHOD_REGEXP = /=\z/
-
-    @allowed_columns = nil
+    HOOKS = [
+      :after_create,
+      :after_destroy,
+      :after_save,
+      :after_update,
+      :after_validation,
+      :before_create,
+      :before_destroy,
+      :before_save,
+      :before_update,
+      :before_validation
+    ].freeze
+
+    @cache_anonymous_models = true
     @db = nil
     @db_schema = nil
     @dataset = nil
     @dataset_method_modules = []
-    @default_eager_limit_strategy = true
     @default_set_fields_options = {}
-    @finders = {}
-    @finder_loaders = {}
     @overridable_methods_module = nil
     @fast_pk_lookup_sql = nil
     @fast_instance_delete_sql = nil
@@ -151,25 +52,34 @@ module Sequel
     @raise_on_save_failure = true
     @raise_on_typecast_failure = false
     @require_modification = nil
+    @require_valid_table = true
     @restrict_primary_key = true
-    @restricted_columns = nil
     @setter_methods = nil
     @simple_pk = nil
     @simple_table = nil
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
-    @use_after_commit_rollback = true
     @use_transactions = true
 
-    Sequel.require %w"default_inflections inflections plugins dataset_module base exceptions errors", "model"
+    require_relative "model/default_inflections"
+    require_relative "model/inflections"
+    require_relative "model/plugins"
+    require_relative "model/dataset_module"
+    require_relative "model/base"
+    require_relative "model/exceptions"
+    require_relative "model/errors"
+    # :nocov:
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
-      Sequel.require 'associations', 'model'
+    # :nocov:
+      require_relative 'model/associations'
       plugin Model::Associations
     end
 
+    def_Model(::Sequel)
+
     # The setter methods (methods ending with =) that are never allowed
-    # to be called automatically via +set+/+update+/+new+/etc..
-    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).grep(SETTER_METHOD_REGEXP)
+    # to be called automatically via +set+/+update+/+new+/etc.
+    RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}.freeze
   end
 end

data/lib/sequel/model/associations.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   class Model
     # Associations are used in order to specify relationships between model classes
@@ -5,45 +7,54 @@ module Sequel
     module Associations
       # Map of association type symbols to association reflection classes.
       ASSOCIATION_TYPES = {}
-    
+
       # Set an empty association reflection hash in the model
       def self.apply(model)
-        model.instance_eval do
+        model.instance_exec do
           @association_reflections = {}
           @autoreloading_associations = {}
           @cache_associations = true
+          @default_eager_limit_strategy = true
+          @default_association_options = {}
+          @default_association_type_options = {}
+          @dataset_module_class = DatasetModule
         end
       end
 
+      # The dataset module to use for classes using the associations plugin.
+      class DatasetModule < Model::DatasetModule
+        def_dataset_caching_method(self, :eager)
+      end
+
       # AssociationReflection is a Hash subclass that keeps information on Sequel::Model associations. It
       # provides methods to reduce internal code duplication.  It should not
       # be instantiated by the user.
       class AssociationReflection < Hash
         include Sequel::Inflections
-    
+
         # Name symbol for the _add internal association method
         def _add_method
-          :"_add_#{singularize(self[:name])}"
+          self[:_add_method]
         end
       
         # Name symbol for the _remove_all internal association method
         def _remove_all_method
-          :"_remove_all_#{self[:name]}"
+          self[:_remove_all_method]
         end
       
         # Name symbol for the _remove internal association method
         def _remove_method
-          :"_remove_#{singularize(self[:name])}"
+          self[:_remove_method]
         end
       
         # Name symbol for the _setter association method
         def _setter_method
-          :"_#{self[:name]}="
+          self[:_setter_method]
         end
       
         # Name symbol for the add association method
         def add_method
-          :"add_#{singularize(self[:name])}"
+          self[:add_method]
         end
       
         # Name symbol for association method, the same as the name of the association.
@@ -53,7 +64,13 @@ module Sequel
       
         # The class associated to the current model class via this association
         def associated_class
-          cached_fetch(:class){constantize(self[:class_name])}
+          cached_fetch(:class) do
+            begin
+              constantize(self[:class_name])
+            rescue NameError => e
+              raise NameError, "#{e.message} (this happened when attempting to find the associated class for #{inspect})", e.backtrace
+            end
+          end
         end
 
         # The dataset associated via this association, with the non-instance specific
@@ -65,16 +82,17 @@ module Sequel
 
         # Apply all non-instance specific changes to the given dataset and return it.
         def apply_dataset_changes(ds)
-          ds.extend(AssociationDatasetMethods)
-          ds.association_reflection = self
-          self[:extend].each{|m| ds.extend(m)}
+          ds = ds.with_extend(AssociationDatasetMethods).clone(:association_reflection => self)
+          if exts = self[:reverse_extend]
+            ds = ds.with_extend(*exts)
+          end
           ds = ds.select(*select) if select
           if c = self[:conditions]
             ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
           end
           ds = ds.order(*self[:order]) if self[:order]
           ds = ds.limit(*self[:limit]) if self[:limit]
-          ds = ds.limit(1) if limit_to_single_row?
+          ds = ds.limit(1).skip_limit_check if limit_to_single_row?
           ds = ds.eager(self[:eager]) if self[:eager]
           ds = ds.distinct if self[:distinct]
           ds
@@ -105,12 +123,12 @@ module Sequel
 
         # Apply an eager limit strategy to the dataset, or return the dataset
         # unmodified if it doesn't need an eager limit strategy.
-        def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy)
+        def apply_eager_limit_strategy(ds, strategy=eager_limit_strategy, limit_and_offset=limit_and_offset())
           case strategy
           when :distinct_on
             apply_distinct_on_eager_limit_strategy(ds)
           when :window_function
-            apply_window_function_eager_limit_strategy(ds)
+            apply_window_function_eager_limit_strategy(ds, limit_and_offset)
           else
             ds
           end
@@ -123,10 +141,11 @@ module Sequel
         end
 
         # Use a window function to limit the results of the eager loading dataset.
-        def apply_window_function_eager_limit_strategy(ds)
+        def apply_window_function_eager_limit_strategy(ds, limit_and_offset=limit_and_offset())
           rn = ds.row_number_column 
           limit, offset = limit_and_offset
-          ds = ds.unordered.select_append{|o| o.row_number{}.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
+          ds = ds.unordered.select_append{|o| o.row_number.function.over(:partition=>predicate_key, :order=>ds.opts[:order]).as(rn)}.from_self
+          ds = ds.order(rn) if ds.db.database_type == :mysql
           ds = if !returns_array?
             ds.where(rn => offset ? offset+1 : 1)
           elsif offset
@@ -143,13 +162,13 @@ module Sequel
 
         # If the ruby eager limit strategy is being used, slice the array using the slice
         # range to return the object(s) at the correct offset/limit.
-        def apply_ruby_eager_limit_strategy(rows)
+        def apply_ruby_eager_limit_strategy(rows, limit_and_offset = limit_and_offset())
           name = self[:name]
+          return unless range = slice_range(limit_and_offset)
           if returns_array?
-            range = slice_range
             rows.each{|o| o.associations[name] = o.associations[name][range] || []}
-          elsif slice_range
-            offset = slice_range.begin
+          else
+            offset = range.begin
             rows.each{|o| o.associations[name] = o.associations[name][offset]}
           end
         end
@@ -175,7 +194,7 @@ module Sequel
 
         # Name symbol for the dataset association method
         def dataset_method
-          :"#{self[:name]}_dataset"
+          self[:dataset_method]
         end
       
         # Whether the dataset needs a primary key to function, true by default.
@@ -194,7 +213,13 @@ module Sequel
         # Return an dataset that will load the appropriate associated objects for
         # the given object using this association.
         def association_dataset_for(object)
-          associated_dataset.where(predicate_keys.zip(predicate_key_values(object)))
+          condition = if can_have_associated_objects?(object)
+            predicate_keys.zip(predicate_key_values(object))
+          else
+            false
+          end
+
+          associated_dataset.where(condition)
         end
 
         ASSOCIATION_DATASET_PROC = proc{|r| r.association_dataset_for(self)}
@@ -245,12 +270,31 @@ module Sequel
           end
           strategy = eager_limit_strategy
           cascade = eo[:associations]
+          eager_limit = nil
 
           if eo[:eager_block] || eo[:loader] == false
+            ds = eager_loading_dataset(eo)
+
+            strategy = ds.opts[:eager_limit_strategy] || strategy
+
+            eager_limit =
+              if el = ds.opts[:eager_limit]
+                raise Error, "The :eager_limit dataset option is not supported for associations returning a single record" unless returns_array?
+                strategy ||= true_eager_graph_limit_strategy
+                if el.is_a?(Array)
+                  el
+                else
+                  [el, nil]
+                end
+              else
+                limit_and_offset
+              end
+
             strategy = true_eager_graph_limit_strategy if strategy == :union
             # Correlated subqueries are not supported for regular eager loading
             strategy = :ruby if strategy == :correlated_subquery
-            objects = apply_eager_limit_strategy(eager_loading_dataset(eo), strategy).all
+            strategy = nil if strategy == :ruby && assign_singular?
+            objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
           elsif strategy == :union
             objects = []
             ds = associated_dataset
@@ -269,7 +313,7 @@ module Sequel
 
           objects.each(&block)
           if strategy == :ruby
-            apply_ruby_eager_limit_strategy(rows)
+            apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
           end
         end
 
@@ -284,11 +328,6 @@ module Sequel
           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.
@@ -311,6 +350,44 @@ module Sequel
           {filter_by_associations_conditions_key=>ds}
         end
 
+        # Finalize the association by first attempting to populate the thread-safe cache,
+        # and then transfering the thread-safe cache value to the association itself,
+        # so that a mutex is not needed to get the value.
+        def finalize
+          return unless cache = self[:cache]
+
+          finalizer = proc do |meth, key|
+            next if has_key?(key)
+
+            # Allow calling private methods to make sure caching is done appropriately
+            send(meth)
+            self[key] = cache.delete(key) if cache.has_key?(key)
+          end
+
+          finalize_settings.each(&finalizer)
+
+          unless self[:instance_specific]
+            finalizer.call(:associated_eager_dataset, :associated_eager_dataset)
+            finalizer.call(:filter_by_associations_conditions_dataset, :filter_by_associations_conditions_dataset)
+          end
+
+          nil
+        end
+
+        # Map of methods to cache keys used for finalizing associations.
+        FINALIZE_SETTINGS = {
+          :associated_class=>:class,
+          :associated_dataset=>:_dataset,
+          :eager_limit_strategy=>:_eager_limit_strategy,
+          :placeholder_loader=>:placeholder_loader,
+          :predicate_key=>:predicate_key,
+          :predicate_keys=>:predicate_keys,
+          :reciprocal=>:reciprocal,
+        }.freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+    
         # Whether to handle silent modification failure when adding/removing
         # associated records, false by default.
         def handle_silent_modification_failure?
@@ -327,6 +404,18 @@ module Sequel
           end
         end
 
+        # Show which type of reflection this is, and a guess at what code was used to create the
+        # association.
+        def inspect
+          o = self[:orig_opts].dup
+          o.delete(:class)
+          o.delete(:class_name)
+          o.delete(:block) unless o[:block]
+          o[:class] = self[:orig_class] if self[:orig_class]
+
+          "#<#{self.class} #{self[:model]}.#{self[:type]} #{self[:name].inspect}#{", #{o.inspect[1...-1]}" unless o.empty?}>"
+        end
+
         # The limit and offset for this association (returned as a two element array).
         def limit_and_offset
           if (v = self[:limit]).is_a?(Array)
@@ -348,7 +437,11 @@ module Sequel
           if use_placeholder_loader?
             cached_fetch(:placeholder_loader) do
               Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
-                ds.where(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)})
+                ds = ds.where(Sequel.&(*predicate_keys.map{|k| SQL::BooleanExpression.new(:'=', k, pl.arg)}))
+                if self[:block]
+                  ds = self[:block].call(ds)
+                end
+                ds
               end
             end
           end
@@ -364,16 +457,14 @@ module Sequel
           predicate_key_methods.map{|k| object.get_column_value(k)}
         end
 
-        # Qualify +col+ with the given table name.  If +col+ is an array of columns,
-        # return an array of qualified columns.  Only qualifies Symbols and SQL::Identifier
-        # values, other values are not modified.
+        # Qualify +col+ with the given table name.
         def qualify(table, col)
           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)
+              Sequel::Qualifier.new(table).transform(k)
             end
           end
         end
@@ -419,7 +510,7 @@ module Sequel
     
         # Name symbol for the remove_all_ association method
         def remove_all_method
-          :"remove_all_#{self[:name]}"
+          self[:remove_all_method]
         end
       
         # Whether associated objects need to be removed from the association before
@@ -430,7 +521,7 @@ module Sequel
     
         # Name symbol for the remove_ association method
         def remove_method
-          :"remove_#{singularize(self[:name])}"
+          self[:remove_method]
         end
       
         # Whether to check that an object to be disassociated is already associated to this object, false by default.
@@ -457,11 +548,11 @@ module Sequel
     
         # Name symbol for the setter association method
         def setter_method
-          :"#{self[:name]}="
+          self[:setter_method]
         end
         
         # The range used for slicing when using the :ruby eager limit strategy.
-        def slice_range
+        def slice_range(limit_and_offset = limit_and_offset())
           limit, offset = limit_and_offset
           if limit || offset
             (offset||0)..(limit ? (offset||0)+limit-1 : -1)
@@ -470,49 +561,32 @@ module Sequel
         
         private
 
-        if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
-        # :nocov:
-          # On non-GVL rubies, assume the need to synchronize access.  Store the key
-          # in a special sub-hash that always uses this method to synchronize access.
-          def cached_fetch(key)
-            fetch(key) do
-              return yield unless h = self[:cache]
-              Sequel.synchronize{return h[key] if h.has_key?(key)}
-              value = yield
-              Sequel.synchronize{h[key] = value}
-            end
-          end
-
-          # Cache the value at the given key, synchronizing access.
-          def cached_set(key, value)
-            return unless h = self[:cache]
+        # If the key exists in the reflection hash, return it.
+        # If the key doesn't exist and association reflections are uncached, then yield to get the value.
+        # If the key doesn't exist and association reflection are cached, check the cache and return
+        # the value if present, or yield to get the value, cache the value, and return it.
+        def cached_fetch(key)
+          fetch(key) do
+            return yield unless h = self[:cache]
+            Sequel.synchronize{return h[key] if h.has_key?(key)}
+            value = yield
             Sequel.synchronize{h[key] = value}
           end
-        # :nocov:
-        else
-          # On MRI, use a plain fetch, since the GVL will synchronize access.
-          def cached_fetch(key)
-            fetch(key) do 
-              return yield unless h = self[:cache]
-              h.fetch(key){h[key] = yield}
-            end
-          end
+        end
 
-          # On MRI, just set the value at the key in the cache, since the GVL
-          # will synchronize access.
-          def cached_set(key, value)
-            return unless h = self[:cache]
-            h[key] = value
-          end
+        # Cache the value at the given key if caching.
+        def cached_set(key, value)
+          return unless h = self[:cache]
+          Sequel.synchronize{h[key] = value}
         end
 
         # The base dataset used for the association, before any order/conditions
         # options have been applied.
         def _associated_dataset
-          associated_class.dataset.clone
+          associated_class.dataset
         end
 
-        # Whether for the reciprocal type for the given association can not be
+        # Whether for the reciprocal type for the given association cannot be
         # known in advantage, false by default.
         def ambiguous_reciprocal_type?
           false
@@ -568,10 +642,15 @@ module Sequel
             ds = ds.eager(associations)
           end
           if block = eo[:eager_block]
+            orig_ds = ds
             ds = block.call(ds)
           end
           if eager_loading_use_associated_key?
-            ds = ds.select_append(*associated_key_array)
+            ds = if ds.opts[:eager_graph] && !orig_ds.opts[:eager_graph]
+              block.call(orig_ds.select_append(*associated_key_array))
+            else
+              ds.select_append(*associated_key_array)
+            end
           end
           if self[:eager_graph]
             raise(Error, "cannot eagerly load a #{self[:type]} association that uses :eager_graph") if eager_loading_use_associated_key?
@@ -629,14 +708,12 @@ module Sequel
           v = fetch(:filter_limit_strategy, self[:eager_limit_strategy])
           if v || self[:limit] || !returns_array?
             case v ||= self[:model].default_eager_limit_strategy
-            when :union, :ruby
+            when true, :union, :ruby
               # Can't use a union or ruby-based strategy for filtering by associations, switch to default eager graph limit
               # strategy.
               true_eager_graph_limit_strategy
             when Symbol
               v
-            when true
-              true_eager_graph_limit_strategy
             end
           end
         end
@@ -684,8 +761,8 @@ module Sequel
 
         # If +s+ is an array, map +s+ over the block.  Otherwise, just call the
         # block with +s+.
-        def transform(s)
-          s.is_a?(Array) ? s.map(&Proc.new) : (yield s)
+        def transform(s, &block)
+          s.is_a?(Array) ? s.map(&block) : (yield s)
         end
 
         # What eager limit strategy should be used when true is given as the value,
@@ -728,7 +805,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          !self[:instance_specific] && !self[:eager_graph]
+          self[:use_placeholder_loader]
         end
       end
     
@@ -773,6 +850,18 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :primary_key=>:primary_key,
+          :primary_keys=>:primary_keys,
+          :primary_key_method=>:primary_key_method,
+          :primary_key_methods=>:primary_key_methods,
+          :qualified_primary_key=>:qualified_primary_key,
+          :reciprocal_type=>:reciprocal_type
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # 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}
@@ -917,6 +1006,13 @@ module Sequel
           :"#{underscore(demodulize(self[:model].name))}_id"
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :qualified_primary_key=>:qualified_primary_key
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false.
         def handle_silent_modification_failure?
           self[:raise_on_save_failure] == false
@@ -1022,7 +1118,7 @@ module Sequel
         end
 
         # Support automatic use of correlated subqueries if :ruby option is best available option,
-        # MySQL is not being used, and either the associated class has a non-composite primary key
+        # the database supports them, and either the associated class has a non-composite primary key
         # or the database supports multiple columns in IN.
         def true_eager_graph_limit_strategy
           r = super
@@ -1157,7 +1253,9 @@ module Sequel
             else
               assoc_record.values.delete(left_key_alias)
             end
-            next unless objects = h[hash_key]
+
+            objects = h[hash_key]
+
             if assign_singular
               objects.each do |object| 
                 object.associations[name] ||= assoc_record
@@ -1187,6 +1285,22 @@ module Sequel
           :"#{singularize(self[:name])}_id"
         end
       
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :associated_key_array=>:associated_key_array,
+          :qualified_right_key=>:qualified_right_key,
+          :join_table_source=>:join_table_source,
+          :join_table_alias=>:join_table_alias,
+          :qualified_right_primary_key=>:qualified_right_primary_key,
+          :right_primary_key=>:right_primary_key,
+          :right_primary_keys=>:right_primary_keys,
+          :right_primary_key_method=>:right_primary_key_method,
+          :right_primary_key_methods=>:right_primary_key_methods,
+          :select=>:select
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        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 predicate_key
@@ -1352,10 +1466,20 @@ module Sequel
       # This module contains methods added to all association datasets
       module AssociationDatasetMethods
         # The model object that created the association dataset
-        attr_accessor :model_object
+        def model_object
+          @opts[:model_object]
+        end
     
         # The association reflection related to the association dataset
-        attr_accessor :association_reflection
+        def association_reflection
+          @opts[:association_reflection]
+        end
+        
+        private
+
+        def non_sql_option?(key)
+          super || key == :model_object || key == :association_reflection
+        end
       end
       
       # Each kind of association adds a number of instance methods to the model class which
@@ -1396,7 +1520,7 @@ module Sequel
       #   Project.associations
       #   => [:portfolio, :milestones]
       #   Project.association_reflection(:portfolio)
-      #   => {:type => :many_to_one, :name => :portfolio, ...}
+      #   => #<Sequel::Model::Associations::ManyToOneAssociationReflection Project.many_to_one :portfolio>
       #
       # Associations should not have the same names as any of the columns in the
       # model's current table they reference. If you are dealing with an existing schema that
@@ -1417,11 +1541,20 @@ module Sequel
         attr_reader :autoreloading_associations
 
         # Whether association metadata should be cached in the association reflection.  If not cached, it will be computed
-        # on demand.  In general you only want to set this to default when using code reloading.  When using code reloading,
-        # setting this will make sure that if an associated class is removed or modified, this class will not hang on to
+        # on demand.  In general you only want to set this to false when using code reloading.  When using code reloading,
+        # setting this will make sure that if an associated class is removed or modified, this class will not have a reference to
         # the previous class.
         attr_accessor :cache_associations
 
+        # The default options to use for all associations.  This hash is merged into the association reflection hash for
+        # all association reflections.
+        attr_accessor :default_association_options
+
+        # The default options to use for all associations of a given type.  This is a hash keyed by association type
+        # symbol.  If there is a value for the association type symbol key, the resulting hash will be merged into the
+        # association reflection hash for all association reflections of that type.
+        attr_accessor :default_association_type_options
+
         # The default :eager_limit_strategy option to use for limited or offset associations (default: true, causing Sequel
         # to use what it considers the most appropriate strategy).
         attr_accessor :default_eager_limit_strategy
@@ -1482,16 +1615,23 @@ module Sequel
         # :class :: The associated class or its name as a string or symbol. If not
         #           given, uses the association's name, which is camelized (and
         #           singularized unless the type is :many_to_one, :one_to_one, or one_through_one).  If this is specified
-        #           as a string or symbol, you must specify the full class name (e.g. "SomeModule::MyModel"). 
+        #           as a string or symbol, you must specify the full class name (e.g. "::SomeModule::MyModel"). 
+        # :class_namespace :: If :class is given as a string or symbol, sets the default namespace in which to look for
+        #                     the class.  <tt>class: 'Foo', class_namespace: 'Bar'</tt> looks for <tt>::Bar::Foo</tt>.)
         # :clearer :: Proc used to define the private _remove_all_* method for doing the database work
         #             to remove all objects associated to the current object (*_to_many assocations).
         # :clone :: Merge the current options and block into the options and block used in defining
         #           the given association.  Can be used to DRY up a bunch of similar associations that
         #           all share the same options such as :class and :key, while changing the order and block used.
         # :conditions :: The conditions to use to filter the association, can be any argument passed to where.
-        # :dataset :: A proc that is instance_execed to get the base dataset to use (before the other
+        #                This option is not respected when using eager_graph or association_join, unless it
+        #                is hash or array of two element arrays.  Consider also specifying the :graph_block
+        #                option if the value for this option is not a hash or array of two element arrays
+        #                and you plan to use this association in eager_graph or association_join.
+        # :dataset :: A proc that is used to define the method to get the base dataset to use (before the other
         #             options are applied).  If the proc accepts an argument, it is passed the related
-        #             association reflection.
+        #             association reflection.  It is a best practice to always have the dataset accept an argument
+        #             and use the argument to return the appropriate dataset.
         # :distinct :: Use the DISTINCT clause when selecting associating object, both when
         #              lazy loading and eager loading via .eager (but not when using .eager_graph).
         # :eager :: The associations to eagerly load via +eager+ when loading the associated object(s).
@@ -1551,8 +1691,7 @@ module Sequel
         # :order_eager_graph :: Whether to add the association's order to the graphed dataset's order when graphing
         #                       via +eager_graph+.  Defaults to true, so set to false to disable.
         # :read_only :: Do not add a setter method (for many_to_one or one_to_one associations),
-        #               or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations). Always
-        #               true for one_through_one associations.
+        #               or add_/remove_/remove_all_ methods (for one_to_many and many_to_many associations).
         # :reciprocal :: the symbol name 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
@@ -1583,7 +1722,7 @@ module Sequel
         #                 array of symbols for a composite key association.
         # :primary_key_method :: the method symbol or array of method symbols to call on the associated
         #                        object to get the foreign key values.  Defaults to :primary_key option.
-        # :qualify :: Whether to use qualifier primary keys when loading the association.  The default
+        # :qualify :: Whether to use qualified primary keys when loading the association.  The default
         #             is true, so you must set to false to not qualify.  Qualification rarely causes
         #             problems, but it's necessary to disable in some cases, such as when you are doing
         #             a JOIN USING operation on the column on Oracle.
@@ -1644,7 +1783,7 @@ module Sequel
         #                              Defaults to :right_primary_key option.
         # :uniq :: Adds a after_load callback that makes the array of objects unique.
         def associate(type, name, opts = OPTS, &block)
-          raise(Error, 'invalid association type') unless assoc_class = ASSOCIATION_TYPES[type]
+          raise(Error, 'invalid association type') unless assoc_class = Sequel.synchronize{ASSOCIATION_TYPES[type]}
           raise(Error, 'Model.associate name argument must be a symbol') unless name.is_a?(Symbol)
 
           # dup early so we don't modify opts
@@ -1655,13 +1794,20 @@ module Sequel
             orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
           end
 
-          opts = orig_opts.merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+          opts = Hash[default_association_options]
+          if type_options = default_association_type_options[type]
+            opts.merge!(type_options)
+          end
+          opts.merge!(orig_opts)
+          opts.merge!(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+
           opts[:block] = block if block
-          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block] || orig_opts[:dataset])
+          opts[:instance_specific] = true if orig_opts[:dataset]
+          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block])
             # It's possible the association is instance specific, in that it depends on
             # values other than the foreign key value.  This needs to be checked for
             # in certain places to disable optimizations.
-            opts[:instance_specific] = true
+            opts[:instance_specific] = _association_instance_specific_default(name)
           end
           opts = assoc_class.new.merge!(opts)
 
@@ -1669,10 +1815,8 @@ module Sequel
             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]})")
           end
 
+          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph]
           opts[:eager_block] = opts[: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]
@@ -1680,9 +1824,15 @@ module Sequel
           opts[:graph_conditions] = conds if !opts.include?(:graph_conditions) and Sequel.condition_specifier?(conds)
           opts[:graph_conditions] = opts.fetch(: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, :before_set, :after_set, :extend].each do |cb_type|
-            opts[cb_type] = Array(opts[cb_type])
+          [:before_add, :before_remove, :after_add, :after_remove, :after_load, :before_set, :after_set].each do |cb_type|
+            opts[cb_type] = Array(opts[cb_type]) if opts[cb_type]
           end
+
+          if opts[:extend]
+            opts[:extend] = Array(opts[:extend])
+            opts[:reverse_extend] = opts[:extend].reverse
+          end
+
           late_binding_class_option(opts, opts.returns_array? ? singularize(name) : name)
           
           # Remove :class entry if it exists and is nil, to work with cached_fetch
@@ -1692,6 +1842,7 @@ module Sequel
           def_association_instance_methods(opts)
       
           orig_opts.delete(:clone)
+          opts[:orig_class] = orig_opts[:class] || orig_opts[:class_name]
           orig_opts.merge!(:class_name=>opts[:class_name], :class=>opts[:class], :block=>opts[:block])
           opts[:orig_opts] = orig_opts
           # don't add to association_reflections until we are sure there are no errors
@@ -1713,6 +1864,25 @@ module Sequel
           opts.eager_load_results(eo, &block)
         end
 
+        # Freeze association related metadata when freezing model class.
+        def freeze
+          @association_reflections.freeze.each_value(&:freeze)
+          @autoreloading_associations.freeze.each_value(&:freeze)
+          @default_association_options.freeze
+          @default_association_type_options.freeze
+          @default_association_type_options.each_value(&:freeze)
+
+          super
+        end
+
+        # Finalize all associations such that values that are looked up
+        # dynamically in associated classes are set statically.
+        # As this modifies the associations, it must be done before
+        # calling freeze.
+        def finalize_associations
+          @association_reflections.each_value(&:finalize)
+        end
+
         # Shortcut for adding a many_to_many association, see #associate
         def many_to_many(name, opts=OPTS, &block)
           associate(:many_to_many, name, opts, &block)
@@ -1723,7 +1893,7 @@ module Sequel
           associate(:many_to_one, name, opts, &block)
         end
         
-        # Shortcut for adding a one_through_one association, see #associate.
+        # Shortcut for adding a one_through_one association, see #associate
         def one_through_one(name, opts=OPTS, &block)
           associate(:one_through_one, name, opts, &block)
         end
@@ -1733,15 +1903,21 @@ module Sequel
           associate(:one_to_many, name, opts, &block)
         end
 
-        # Shortcut for adding a one_to_one association, see #associate.
+        # Shortcut for adding a one_to_one association, see #associate
         def one_to_one(name, opts=OPTS, &block)
           associate(:one_to_one, name, opts, &block)
         end
 
-        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
+        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@default_association_type_options=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
+
+        # The default value for the instance_specific option, if the association
+        # could be instance specific and the :instance_specific option is not specified.
+        def _association_instance_specific_default(_)
+          true
+        end
       
         # The module to use for the association's methods.  Defaults to
         # the overridable_methods_module.
@@ -1753,7 +1929,7 @@ module Sequel
         # can be easily overridden in the class itself while allowing for
         # super to be called.
         def association_module_def(name, opts=OPTS, &block)
-          association_module(opts).module_eval{define_method(name, &block)}
+          association_module(opts).send(:define_method, name, &block)
         end
       
         # Add a private method to the module included in the class.
@@ -1764,42 +1940,64 @@ module Sequel
 
         # Adds the association method to the association methods module.
         def def_association_method(opts)
-          association_module_def(opts.association_method, opts){|*dynamic_opts, &block| load_associated_objects(opts, dynamic_opts[0], &block)}
+          association_module_def(opts.association_method, opts) do |dynamic_opts=OPTS, &block|
+            load_associated_objects(opts, dynamic_opts, &block)
+          end
         end
       
         # Define all of the association instance methods for this association.
         def def_association_instance_methods(opts)
+          # Always set the method names in the association reflection, even if they
+          # are not used, for backwards compatibility.
+          opts[:dataset_method] = :"#{opts[:name]}_dataset"
+          if opts.returns_array?
+            sname = singularize(opts[:name])
+            opts[:_add_method] = :"_add_#{sname}"
+            opts[:add_method] = :"add_#{sname}"
+            opts[:_remove_method] = :"_remove_#{sname}"
+            opts[:remove_method] = :"remove_#{sname}"
+            opts[:_remove_all_method] = :"_remove_all_#{opts[:name]}"
+            opts[:remove_all_method] = :"remove_all_#{opts[:name]}"
+          else
+            opts[:_setter_method] = :"_#{opts[:name]}="
+            opts[:setter_method] = :"#{opts[:name]}="
+          end
+
           association_module_def(opts.dataset_method, opts){_dataset(opts)}
+          if opts[:block]
+            opts[:block_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_block", 1, &opts[:block])
+          end
+          opts[:dataset_opt_arity] = opts[:dataset].arity == 0 ? 0 : 1
+          opts[:dataset_opt_method] = Plugins.def_sequel_method(association_module(opts), "#{opts[:name]}_dataset_opt", opts[:dataset_opt_arity], &opts[:dataset])
           def_association_method(opts)
 
           return if opts[:read_only]
 
           if opts[:setter] && opts[:_setter]
             # This is backwards due to backwards compatibility
-            association_module_private_def(opts._setter_method, opts, &opts[:setter])
-            association_module_def(opts.setter_method, opts, &opts[:_setter])
+            association_module_private_def(opts[:_setter_method], opts, &opts[:setter])
+            association_module_def(opts[:setter_method], opts, &opts[:_setter])
           end
 
           if adder = opts[:adder]
-            association_module_private_def(opts._add_method, opts, &adder)
-            association_module_def(opts.add_method, opts){|o,*args| add_associated_object(opts, o, *args)}
+            association_module_private_def(opts[:_add_method], opts, &adder)
+            association_module_def(opts[:add_method], opts){|o,*args| add_associated_object(opts, o, *args)}
           end
 
           if remover = opts[:remover]
-            association_module_private_def(opts._remove_method, opts, &remover)
-            association_module_def(opts.remove_method, opts){|o,*args| remove_associated_object(opts, o, *args)}
+            association_module_private_def(opts[:_remove_method], opts, &remover)
+            association_module_def(opts[:remove_method], opts){|o,*args| remove_associated_object(opts, o, *args)}
           end
 
           if clearer = opts[:clearer]
-            association_module_private_def(opts._remove_all_method, opts, &clearer)
-            association_module_def(opts.remove_all_method, opts){|*args| remove_all_associated_objects(opts, *args)}
+            association_module_private_def(opts[:_remove_all_method], opts, &clearer)
+            association_module_def(opts[:remove_all_method], opts){|*args| remove_all_associated_objects(opts, *args)}
           end
         end
         
         # Configures many_to_many and one_through_one association reflection and adds the related association methods
         def def_many_to_many(opts)
           one_through_one = opts[:type] == :one_through_one
-          opts[:read_only] = true if one_through_one
           left = (opts[:left_key] ||= opts.default_left_key)
           lcks = opts[:left_keys] = Array(left)
           right = (opts[:right_key] ||= opts.default_right_key)
@@ -1820,7 +2018,10 @@ module Sequel
           join_table = (opts[:join_table] ||= opts.default_join_table)
           opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:graph_join_table_join_type] ||= opts[:graph_join_type]
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= opts.association_dataset_proc
           opts[:eager_loader] ||= opts.method(:default_eager_loader)
           
@@ -1853,21 +2054,54 @@ module Sequel
             end
           end
       
-          return if opts[:read_only] || one_through_one
+          return if opts[:read_only]
       
-          opts[:adder] ||= proc do |o|
-            h = {}
-            lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
-            rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
-            _join_table_dataset(opts).insert(h)
-          end
+          if one_through_one
+            opts[:setter] ||= proc do |o|
+              h = {}
+              lh = lcks.zip(lcpks.map{|k| get_column_value(k)})
+              jtds = _join_table_dataset(opts).where(lh)
 
-          opts[:remover] ||= proc do |o|
-            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
-          end
+              checked_transaction do
+                current = jtds.first
+
+                if o
+                  new_values = []
+                  rcks.zip(opts.right_primary_key_methods).each{|k, pk| new_values << (h[k] = o.get_column_value(pk))}
+                end
+
+                if current
+                  current_values = rcks.map{|k| current[k]}
+                  jtds = jtds.where(rcks.zip(current_values))
+                  if o
+                    if current_values != new_values
+                      jtds.update(h)
+                    end
+                  else
+                    jtds.delete
+                  end
+                elsif o
+                  lh.each{|k,v| h[k] = v}
+                  jtds.insert(h)
+                end
+              end
+            end
+            opts[:_setter] = proc{|o| set_one_through_one_associated_object(opts, o)}
+          else 
+            opts[:adder] ||= proc do |o|
+              h = {}
+              lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
+              rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
+              _join_table_dataset(opts).insert(h)
+            end
+
+            opts[:remover] ||= proc do |o|
+              _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
+            end
 
-          opts[:clearer] ||= proc do
-            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
+            opts[:clearer] ||= proc do
+              _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
+            end
           end
         end
 
@@ -1905,9 +2139,7 @@ module Sequel
 
             eager_load_results(opts, eo) do |assoc_record|
               hash_key = uses_cks ? pk_meths.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(opts.primary_key_method)
-              if objects = h[hash_key]
-                objects.each{|object| object.associations[name] = assoc_record}
-              end
+              h[hash_key].each{|object| object.associations[name] = assoc_record}
             end
           end
       
@@ -1920,7 +2152,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, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &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=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
           end
       
           return if opts[:read_only]
@@ -1954,7 +2186,7 @@ module Sequel
             eager_load_results(opts, eo) do |assoc_record|
               assoc_record.values.delete(delete_rn) if delete_rn
               hash_key = uses_cks ? km.map{|k| assoc_record.get_column_value(k)} : assoc_record.get_column_value(km)
-              next unless objects = h[hash_key]
+              objects = h[hash_key]
               if assign_singular
                 objects.each do |object| 
                   unless object.associations[name]
@@ -1980,7 +2212,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, Hash[eo].merge!(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep, :from_self_alias=>eo[:from_self_alias]), &graph_block)
+            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &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
@@ -1995,12 +2227,28 @@ module Sequel
           if one_to_one
             opts[:setter] ||= proc do |o|
               up_ds = _apply_association_options(opts, opts.associated_dataset.where(cks.zip(cpks.map{|k| get_column_value(k)})))
+
+              if (froms = up_ds.opts[:from]) && (from = froms[0]) && (from.is_a?(Sequel::Dataset) || (from.is_a?(Sequel::SQL::AliasedExpression) && from.expression.is_a?(Sequel::Dataset)))
+                if old = up_ds.first
+                  cks.each{|k| old.set_column_value(:"#{k}=", nil)}
+                end
+                save_old = true
+              end
+
               if o
-                up_ds = up_ds.exclude(o.pk_hash) unless o.new?
+                if !o.new? && !save_old
+                  up_ds = up_ds.exclude(o.pk_hash)
+                end
                 cks.zip(cpks).each{|k, pk| o.set_column_value(:"#{k}=", get_column_value(pk))}
               end
+
               checked_transaction do
-                up_ds.update(ck_nil_hash)
+                if save_old
+                  old.save(save_opts) || raise(Sequel::Error, "invalid previously associated object, cannot save") if old
+                else
+                  up_ds.skip_limit_check.update(ck_nil_hash)
+                end
+
                 o.save(save_opts) || raise(Sequel::Error, "invalid associated object, cannot save") if o
               end
             end
@@ -2063,8 +2311,10 @@ module Sequel
         # retrieving associations after freezing will still work in most cases,
         # but the associations will not be cached in the association cache.
         def freeze
-          associations.freeze
+          associations
           super
+          associations.freeze
+          self
         end
       
         private
@@ -2074,15 +2324,16 @@ module Sequel
           unless ds.kind_of?(AssociationDatasetMethods)
             ds = opts.apply_dataset_changes(ds)
           end
-          ds.model_object = self
+          ds = ds.clone(:model_object => self)
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
-          ds = instance_exec(ds, &opts[:block]) if opts[:block]
+          # block method is private
+          ds = send(opts[:block_method], ds) if opts[:block_method]
           ds
         end
 
         # Return a dataset for the association after applying any dynamic callback.
         def _associated_dataset(opts, dynamic_opts)
-          ds = send(opts.dataset_method)
+          ds = public_send(opts.dataset_method)
           if callback = dynamic_opts[:callback]
             ds = callback.call(ds)
           end
@@ -2099,10 +2350,11 @@ module Sequel
         # Return an association dataset for the given association reflection
         def _dataset(opts)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          ds = if opts[:dataset].arity == 1
-            instance_exec(opts, &opts[:dataset])
+          ds = if opts[:dataset_opt_arity] == 1
+            # dataset_opt_method is private
+            send(opts[:dataset_opt_method], opts)
           else
-            instance_exec(&opts[:dataset])
+            send(opts[:dataset_opt_method])
           end
           _apply_association_options(opts, ds)
         end
@@ -2158,18 +2410,12 @@ module Sequel
 
         # Add the given associated object to the given association
         def add_associated_object(opts, o, *args)
-          klass = opts.associated_class
-          if o.is_a?(Hash)
-            o = klass.new(o)
-          elsif o.is_a?(Integer) || o.is_a?(String) || o.is_a?(Array)
-            o = klass.with_pk!(o)
-          elsif !o.is_a?(klass)
-            raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
-          end
+          o = make_add_associated_object(opts, o)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
           ensure_associated_primary_key(opts, o, *args)
           return if run_association_callbacks(opts, :before_add, o) == false
-          return if !send(opts._add_method, o, *args) && opts.handle_silent_modification_failure?
+          # Allow calling private _add method
+          return if !send(opts[:_add_method], o, *args) && opts.handle_silent_modification_failure?
           if array = associations[opts[:name]] and !array.include?(o)
             array.push(o)
           end
@@ -2201,7 +2447,32 @@ module Sequel
         # cached associations.
         def change_column_value(column, value)
           if assocs = model.autoreloading_associations[column]
-            assocs.each{|a| associations.delete(a)}
+            vals = @values
+            if new?
+              # Do deeper checking for new objects, so that associations are
+              # not deleted when values do not change.  This code is run at
+              # a higher level for existing objects.
+              if value == (c = vals[column]) && value.class == c.class
+                # If the value is the same, there is no reason to delete
+                # the related associations, so exit early in that case.
+                return super
+              end
+
+              only_delete_nil = c.nil?
+            elsif vals[column].nil?
+              only_delete_nil = true
+            end
+
+            if only_delete_nil
+              # If the current foreign key value is nil, but the association
+              # is already present in the cache, it was probably added to the
+              # cache for a reason, and we do not want to delete it in that case.
+              # However, we still want to delete associations with nil values
+              # to remove the cached false negative.
+              assocs.each{|a| associations.delete(a) if associations[a].nil?}
+            else
+              assocs.each{|a| associations.delete(a)}
+            end
           end
           super
         end
@@ -2223,18 +2494,21 @@ module Sequel
           self
         end
 
-        # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
-        def load_associated_objects(opts, dynamic_opts=nil)
-          if dynamic_opts == true or dynamic_opts == false or dynamic_opts == nil
-            dynamic_opts = {:reload=>dynamic_opts}
-          elsif dynamic_opts.respond_to?(:call)
-            dynamic_opts = {:callback=>dynamic_opts}
-          end
-          if block_given?
-            dynamic_opts = Hash[dynamic_opts].merge!(:callback=>Proc.new)
+        # If a block is given, assign it as the :callback option in the hash, and return the hash.
+        def load_association_objects_options(dynamic_opts, &block)
+          if block
+            dynamic_opts = Hash[dynamic_opts]
+            dynamic_opts[:callback] = block
           end
+
+          dynamic_opts
+        end
+
+        # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
+        def load_associated_objects(opts, dynamic_opts, &block)
+          dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
-          if associations.include?(name) and !dynamic_opts[:callback] and !dynamic_opts[:reload]
+          if associations.include?(name) && !dynamic_opts[:callback] && !dynamic_opts[:reload]
             associations[name]
           else
             objs = _load_associated_objects(opts, dynamic_opts)
@@ -2263,10 +2537,30 @@ module Sequel
             opts.send(:cached_fetch, :many_to_one_pk_lookup){opts.primary_key == opts.associated_class.primary_key}
         end
         
+        # Convert the input of the add_* association method into an associated object. For
+        # hashes, this creates a new object using the hash.  For integers, strings, and arrays,
+        # assume the value specifies a primary key, and lookup an existing object with that primary key.
+        # Otherwise, if the object is not already an instance of the class, raise an exception.
+        def make_add_associated_object(opts, o)
+          klass = opts.associated_class
+
+          case o
+          when Hash
+            klass.new(o)
+          when Integer, String, Array
+            klass.with_pk!(o)
+          when klass
+            o
+          else 
+            raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
+          end
+        end
+
         # Remove all associated objects from the given association
         def remove_all_associated_objects(opts, *args)
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
-          send(opts._remove_all_method, *args)
+          # Allow calling private _remove_all method
+          send(opts[:_remove_all_method], *args)
           ret = associations[opts[:name]].each{|o| remove_reciprocal_object(opts, o)} if associations.include?(opts[:name])
           associations[opts[:name]] = []
           ret
@@ -2279,13 +2573,14 @@ module Sequel
             o = remove_check_existing_object_from_pk(opts, o, *args)
           elsif !o.is_a?(klass)
             raise(Sequel::Error, "associated object #{o.inspect} not of correct type #{klass}")
-          elsif opts.remove_should_check_existing? && send(opts.dataset_method).where(o.pk_hash).empty?
+          elsif opts.remove_should_check_existing? && public_send(opts.dataset_method).where(o.pk_hash).empty?
             raise(Sequel::Error, "associated object #{o.inspect} is not currently associated to #{inspect}")
           end
           raise(Sequel::Error, "model object #{inspect} does not have a primary key") if opts.dataset_need_primary_key? && !pk
           raise(Sequel::Error, "associated object #{o.inspect} does not have a primary key") if opts.need_associated_primary_key? && !o.pk
           return if run_association_callbacks(opts, :before_remove, o) == false
-          return if !send(opts._remove_method, o, *args) && opts.handle_silent_modification_failure?
+          # Allow calling private _remove method
+          return if !send(opts[:_remove_method], o, *args) && opts.handle_silent_modification_failure?
           associations[opts[:name]].delete_if{|x| o === x} if associations.include?(opts[:name])
           remove_reciprocal_object(opts, o)
           run_association_callbacks(opts, :after_remove, o)
@@ -2298,7 +2593,7 @@ module Sequel
         def remove_check_existing_object_from_pk(opts, o, *args)
           key = o
           pkh = opts.associated_class.qualified_primary_key_hash(key)
-          raise(Sequel::Error, "no object with key(s) #{key.inspect} is currently associated to #{inspect}") unless o = send(opts.dataset_method).first(pkh)
+          raise(Sequel::Error, "no object with key(s) #{key.inspect} is currently associated to #{inspect}") unless o = public_send(opts.dataset_method).first(pkh)
           o
         end
 
@@ -2316,40 +2611,52 @@ module Sequel
 
         # Run the callback for the association with the object.
         def run_association_callbacks(reflection, callback_type, object)
-          # The reason we automatically set raise_error for singular associations is that
-          # assignment in ruby always returns the argument instead of the result of the
-          # method, so we can't return nil to signal that the association callback prevented
-          # the modification
-          raise_error = raise_on_save_failure || !reflection.returns_array?
-          stop_on_false = [:before_add, :before_remove, :before_set].include?(callback_type)
-          reflection[callback_type].each do |cb|
-            res = case cb
-            when Symbol
-              send(cb, object)
-            when Proc
-              cb.call(self, object)
-            else
-              raise Error, "callbacks should either be Procs or Symbols"
-            end
-
-            if res == false and stop_on_false
-              raise(HookFailed, "Unable to modify association for #{inspect}: one of the #{callback_type} hooks returned false")
+          return unless cbs = reflection[callback_type]
+
+          begin
+            cbs.each do |cb|
+              case cb
+              when Symbol
+                # Allow calling private methods in association callbacks
+                send(cb, object)
+              when Proc
+                cb.call(self, object)
+              else
+                raise Error, "callbacks should either be Procs or Symbols"
+              end
             end
+          rescue HookFailed
+            # The reason we automatically set raise_error for singular associations is that
+            # assignment in ruby always returns the argument instead of the result of the
+            # method, so we can't return nil to signal that the association callback prevented
+            # the modification
+            return false unless raise_on_save_failure || !reflection.returns_array?
+            raise
           end
-        rescue HookFailed
-          return false unless raise_error
-          raise
         end
 
         # Set the given object as the associated object for the given *_to_one association reflection
         def _set_associated_object(opts, o)
           a = associations[opts[:name]]
-          return if a && a == o && !set_associated_object_if_same?
+          reciprocal = opts.reciprocal
+          if set_associated_object_if_same?
+            if reciprocal
+              remove_reciprocal = a && (a != o || a.associations[reciprocal] != self)
+              add_reciprocal = o && o.associations[reciprocal] != self
+            end
+          else
+            return if a && a == o
+            if reciprocal
+              remove_reciprocal = a
+              add_reciprocal = o
+            end
+          end
           run_association_callbacks(opts, :before_set, o)
-          remove_reciprocal_object(opts, a) if a
-          send(opts._setter_method, o)
+          remove_reciprocal_object(opts, a) if remove_reciprocal
+          # Allow calling private _setter method
+          send(opts[:_setter_method], o)
           associations[opts[:name]] = o
-          add_reciprocal_object(opts, o) if o
+          add_reciprocal_object(opts, o) if add_reciprocal
           run_association_callbacks(opts, :after_set, o)
           o
         end
@@ -2367,6 +2674,13 @@ module Sequel
           _set_associated_object(opts, o)
         end
 
+        # Set the given object as the associated object for the given one_through_one association reflection
+        def set_one_through_one_associated_object(opts, o)
+          raise(Error, "object #{inspect} does not have a primary key") unless pk
+          raise(Error, "associated object #{o.inspect} does not have a primary key") if o && !o.pk
+          _set_associated_object(opts, o)
+        end
+
         # Set the given object as the associated object for the given one_to_one association reflection
         def set_one_to_one_associated_object(opts, o)
           raise(Error, "object #{inspect} does not have a primary key") unless pk
@@ -2397,48 +2711,112 @@ module Sequel
       #   Album.eager(:artist, :genre).all
       #   Album.eager_graph(:artist, :genre).all
       #   Album.eager(:artist).eager(:genre).all
-      #   Album.eager_graph(:artist).eager(:genre).all
-      #   Artist.eager(:albums=>:tracks).all
-      #   Artist.eager_graph(:albums=>:tracks).all
-      #   Artist.eager(:albums=>{:tracks=>:genre}).all
-      #   Artist.eager_graph(:albums=>{:tracks=>:genre}).all
+      #   Album.eager_graph(:artist).eager_graph(:genre).all
+      #   Artist.eager(albums: :tracks).all
+      #   Artist.eager_graph(albums: :tracks).all
+      #   Artist.eager(albums: {tracks: :genre}).all
+      #   Artist.eager_graph(albums: {tracks: :genre}).all
       #
       # You can also pass a callback as a hash value in order to customize the dataset being
       # eager loaded at query time, analogous to the way the :eager_block association option
       # allows you to customize it at association definition time. For example,
       # if you wanted artists with their albums since 1990:
       #
-      #   Artist.eager(:albums => proc{|ds| ds.where{year > 1990}})
+      #   Artist.eager(albums: proc{|ds| ds.where{year > 1990}})
       #
       # Or if you needed albums and their artist's name only, using a single query:
       #
-      #   Albums.eager_graph(:artist => proc{|ds| ds.select(:name)})
+      #   Albums.eager_graph(artist: proc{|ds| ds.select(:name)})
       #
       # To cascade eager loading while using a callback, you substitute the cascaded
       # associations with a single entry hash that has the proc callback as the key and 
       # the cascaded associations as the value.  This will load artists with their albums
       # since 1990, and also the tracks on those albums and the genre for those tracks:
       #
-      #   Artist.eager(:albums => {proc{|ds| ds.where{year > 1990}}=>{:tracks => :genre}})
+      #   Artist.eager(albums: {proc{|ds| ds.where{year > 1990}}=>{tracks: :genre}})
       module DatasetMethods
-        Sequel::Dataset.def_mutation_method(:eager, :eager_graph, :module=>self)
-
         %w'inner left right full'.each do |type|
-          class_eval <<END, __FILE__, __LINE__+1
+          class_eval(<<-END, __FILE__, __LINE__+1)
             def association_#{type}_join(*associations)
               _association_join(:#{type}, associations)
             end
-END
+          END
         end
 
         # Adds one or more INNER JOINs to the existing dataset using the keys and conditions
-        # specified by the given association.  The following methods also exist for specifying
-        # a different type of JOIN:
+        # specified by the given association(s).  Take the same arguments as eager_graph, and
+        # operates similarly, but only adds the joins as opposed to making the other changes
+        # (such as adding selected columns and setting up eager loading).
+        #
+        # The following methods also exist for specifying a different type of JOIN:
         #
         # association_full_join :: FULL JOIN
         # association_inner_join :: INNER JOIN
         # association_left_join :: LEFT JOIN
         # association_right_join :: RIGHT JOIN
+        #
+        # Examples:
+        #
+        #   # For each album, association_join load the artist
+        #   Album.association_join(:artist).all
+        #   # SELECT *
+        #   # FROM albums
+        #   # INNER JOIN artists AS artist ON (artists.id = albums.artist_id)
+        #
+        #   # For each album, association_join load the artist, using a specified alias
+        #   Album.association_join(Sequel[:artist].as(:a)).all
+        #   # SELECT *
+        #   # FROM albums
+        #   # INNER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
+        #   # For each album, association_join load the artist and genre
+        #   Album.association_join(:artist, :genre).all
+        #   Album.association_join(:artist).association_join(:genre).all
+        #   # SELECT *
+        #   # FROM albums
+        #   # INNER JOIN artists AS artist ON (artist.id = albums.artist_id)
+        #   # INNER JOIN genres AS genre ON (genre.id = albums.genre_id)
+        #
+        #   # For each artist, association_join load albums and tracks for each album
+        #   Artist.association_join(albums: :tracks).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN tracks ON (tracks.album_id = albums.id)
+        #
+        #   # For each artist, association_join load albums, tracks for each album, and genre for each track
+        #   Artist.association_join(albums: {tracks: :genre}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN tracks ON (tracks.album_id = albums.id)
+        #   # INNER JOIN genres AS genre ON (genre.id = tracks.genre_id)
+        #
+        #   # For each artist, association_join load albums with year > 1990
+        #   Artist.association_join(albums: proc{|ds| ds.where{year > 1990}}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #
+        #   # For each artist, association_join load albums and tracks 1-10 for each album
+        #   Artist.association_join(albums: {tracks: proc{|ds| ds.where(number: 1..10)}}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN (
+        #   #   SELECT * FROM tracks WHERE ((number >= 1) AND (number <= 10))
+        #   # ) AS tracks ON (tracks.albums_id = albums.id)
+        #
+        #   # For each artist, association_join load albums with year > 1990, and tracks for those albums
+        #   Artist.association_join(albums: {proc{|ds| ds.where{year > 1990}}=>:tracks}).all
+        #   # SELECT *
+        #   # FROM artists 
+        #   # INNER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #   # INNER JOIN tracks ON (tracks.album_id = albums.id)
         def association_join(*associations)
           association_inner_join(*associations)
         end
@@ -2451,10 +2829,10 @@ END
         # types, this is a simple transformation, but for +many_to_many+ associations this 
         # creates a subquery to the join table.
         def complex_expression_sql_append(sql, op, args)
-          r = args.at(1)
-          if (((op == :'=' || op == :'!=') and r.is_a?(Sequel::Model)) ||
-              (multiple = ((op == :IN || op == :'NOT IN') and ((is_ds = r.is_a?(Sequel::Dataset)) or r.all?{|x| x.is_a?(Sequel::Model)}))))
-            l = args.at(0)
+          r = args[1]
+          if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
+              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
+            l = args[0]
             if ar = model.association_reflections[l]
               if multiple
                 klass = ar.associated_class
@@ -2509,7 +2887,7 @@ END
         # it avoids problems such as aliasing conflicts and creating cartesian product
         # result sets if multiple one_to_many or many_to_many eager associations are requested.
         #
-        # One limitation of using this method is that you cannot filter the dataset
+        # One limitation of using this method is that you cannot filter the current dataset
         # based on values of columns in an associated table, since the associations are loaded
         # in separate queries.  To do that you need to load all associations in the
         # same query, and extract an object graph from the results of that query. If you
@@ -2518,15 +2896,66 @@ END
         #
         # Each association's order, if defined, is respected.
         # If the association uses a block or has an :eager_block argument, it is used.
+        #
+        # To modify the associated dataset that will be used for the eager load, you should use a
+        # hash for the association, with the key being the association name symbol, and the value being
+        # a callable object that is called with the associated dataset and should return a modified
+        # dataset.  If that association also has dependent associations, instead of a callable object,
+        # use a hash with the callable object being the key, and the dependent association(s) as the value.
+        #
+        # Examples:
+        #
+        #   # For each album, eager load the artist
+        #   Album.eager(:artist).all
+        #   # SELECT * FROM albums
+        #   # SELECT * FROM artists WHERE (id IN (...))
+        #
+        #   # For each album, eager load the artist and genre
+        #   Album.eager(:artist, :genre).all
+        #   Album.eager(:artist).eager(:genre).all
+        #   # SELECT * FROM albums
+        #   # SELECT * FROM artists WHERE (id IN (...))
+        #   # SELECT * FROM genres WHERE (id IN (...))
+        #
+        #   # For each artist, eager load albums and tracks for each album
+        #   Artist.eager(albums: :tracks).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
+        #   # SELECT * FROM tracks WHERE (album_id IN (...))
+        #
+        #   # For each artist, eager load albums, tracks for each album, and genre for each track
+        #   Artist.eager(albums: {tracks: :genre}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
+        #   # SELECT * FROM tracks WHERE (album_id IN (...))
+        #   # SELECT * FROM genre WHERE (id IN (...))
+        #
+        #   # For each artist, eager load albums with year > 1990
+        #   Artist.eager(albums: proc{|ds| ds.where{year > 1990}}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE ((year > 1990) AND (artist_id IN (...)))
+        #
+        #   # For each artist, eager load albums and tracks 1-10 for each album
+        #   Artist.eager(albums: {tracks: proc{|ds| ds.where(number: 1..10)}}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
+        #   # SELECT * FROM tracks WHERE ((number >= 1) AND (number <= 10) AND (album_id IN (...)))
+        #
+        #   # For each artist, eager load albums with year > 1990, and tracks for those albums
+        #   Artist.eager(albums: {proc{|ds| ds.where{year > 1990}}=>:tracks}).all
+        #   # SELECT * FROM artists
+        #   # SELECT * FROM albums WHERE ((year > 1990) AND (artist_id IN (...)))
+        #   # SELECT * FROM albums WHERE (artist_id IN (...))
         def eager(*associations)
           opts = @opts[:eager]
           association_opts = eager_options_for_associations(associations)
-          opts = opts ? Hash[opts].merge!(association_opts) : association_opts
-          clone(:eager=>opts)
+          opts = opts ? opts.merge(association_opts) : association_opts
+          clone(:eager=>opts.freeze)
         end
 
         # The secondary eager loading method.  Loads all associations in a single query. This
-        # method should only be used if you need to filter or order based on columns in associated tables.
+        # method should only be used if you need to filter or order based on columns in associated tables,
+        # or if you have done comparative benchmarking it and determined it is faster.
         #
         # This method uses <tt>Dataset#graph</tt> to create appropriate aliases for columns in all the
         # tables.  Then it uses the graph's metadata to build the associations from the single hash, and
@@ -2534,9 +2963,9 @@ END
         #
         # Be very careful when using this with multiple one_to_many or many_to_many associations, as you can
         # create large cartesian products.  If you must graph multiple one_to_many and many_to_many associations,
-        # make sure your filters are narrow if you have a large database.
+        # make sure your filters are narrow if the datasets are large.
         # 
-        # Each association's order, if definied, is respected. +eager_graph+ probably
+        # Each association's order, if defined, is respected. +eager_graph+ probably
         # won't work correctly on a limited dataset, unless you are
         # only graphing many_to_one, one_to_one, and one_through_one associations.
         # 
@@ -2545,6 +2974,86 @@ END
         #
         # Like +eager+, you need to call +all+ on the dataset for the eager loading to work.  If you just
         # call +each+, it will yield plain hashes, each containing all columns from all the tables.
+        #
+        # To modify the associated dataset that will be joined to the current dataset, you should use a
+        # hash for the association, with the key being the association name symbol, and the value being
+        # a callable object that is called with the associated dataset and should return a modified
+        # dataset.  If that association also has dependent associations, instead of a callable object,
+        # use a hash with the callable object being the key, and the dependent association(s) as the value.
+        # 
+        # You can specify an custom alias and/or join type on a per-association basis by providing an
+        # Sequel::SQL::AliasedExpression object instead of an a Symbol for the association name.
+        #
+        # Examples:
+        #
+        #   # For each album, eager_graph load the artist
+        #   Album.eager_graph(:artist).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # LEFT OUTER JOIN artists AS artist ON (artists.id = albums.artist_id)
+        #
+        #   # For each album, eager_graph load the artist, using a specified alias
+        #   Album.eager_graph(Sequel[:artist].as(:a)).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # LEFT OUTER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
+        #   # For each album, eager_graph load the artist, using a specified alias
+        #   # and custom join type
+        #
+        #   Album.eager_graph(Sequel[:artist].as(:a, join_type: :inner)).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # INNER JOIN artists AS a ON (a.id = albums.artist_id)
+        #
+        #   # For each album, eager_graph load the artist and genre
+        #   Album.eager_graph(:artist, :genre).all
+        #   Album.eager_graph(:artist).eager_graph(:genre).all
+        #   # SELECT ...
+        #   # FROM albums
+        #   # LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id)
+        #   # LEFT OUTER JOIN genres AS genre ON (genre.id = albums.genre_id)
+        #
+        #   # For each artist, eager_graph load albums and tracks for each album
+        #   Artist.eager_graph(albums: :tracks).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
+        #
+        #   # For each artist, eager_graph load albums, tracks for each album, and genre for each track
+        #   Artist.eager_graph(albums: {tracks: :genre}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
+        #   # LEFT OUTER JOIN genres AS genre ON (genre.id = tracks.genre_id)
+        #
+        #   # For each artist, eager_graph load albums with year > 1990
+        #   Artist.eager_graph(albums: proc{|ds| ds.where{year > 1990}}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #
+        #   # For each artist, eager_graph load albums and tracks 1-10 for each album
+        #   Artist.eager_graph(albums: {tracks: proc{|ds| ds.where(number: 1..10)}}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN (
+        #   #   SELECT * FROM tracks WHERE ((number >= 1) AND (number <= 10))
+        #   # ) AS tracks ON (tracks.albums_id = albums.id)
+        #
+        #   # For each artist, eager_graph load albums with year > 1990, and tracks for those albums
+        #   Artist.eager_graph(albums: {proc{|ds| ds.where{year > 1990}}=>:tracks}).all
+        #   # SELECT ...
+        #   # FROM artists 
+        #   # LEFT OUTER JOIN (
+        #   #   SELECT * FROM albums WHERE (year > 1990)
+        #   # ) AS albums ON (albums.artist_id = artists.id)
+        #   # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
         def eager_graph(*associations)
           eager_graph_with_options(associations)
         end
@@ -2570,8 +3079,11 @@ END
         #                    significantly slower in some cases (perhaps even the majority of cases), so you should
         #                    only use this if you have benchmarked that it is faster for your use cases.
         def eager_graph_with_options(associations, opts=OPTS)
+          return self if associations.empty?
+
+          opts = opts.dup unless opts.frozen?
           associations = [associations] unless associations.is_a?(Array)
-          if eg = @opts[:eager_graph]
+          ds = if eg = @opts[:eager_graph]
             eg = eg.dup
             [:requirements, :reflections, :reciprocals, :limits].each{|k| eg[k] = eg[k].dup}
             eg[:local] = opts
@@ -2585,8 +3097,32 @@ END
             # :limits :: Any limit/offset array slicing that need to be handled in ruby land after loading
             opts = {:requirements=>{}, :master=>alias_symbol(first_source), :reflections=>{}, :reciprocals=>{}, :limits=>{}, :local=>opts, :cartesian_product_number=>0, :row_proc=>row_proc}
             ds = clone(:eager_graph=>opts)
-            ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
+            ds = ds.eager_graph_associations(ds, model, ds.opts[:eager_graph][:master], [], *associations).naked
           end
+
+          ds.opts[:eager_graph].freeze
+          ds.opts[:eager_graph].each_value{|v| v.freeze if v.is_a?(Hash)}
+          ds
+        end
+
+        # If the dataset is being eagerly loaded, default to calling all
+        # instead of each.
+        def as_hash(key_column=nil, value_column=nil, opts=OPTS)
+          if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
+            opts = Hash[opts]
+            opts[:all] = true
+          end
+          super
+        end
+
+        # If the dataset is being eagerly loaded, default to calling all
+        # instead of each.
+        def to_hash_groups(key_column, value_column=nil, opts=OPTS)
+          if (@opts[:eager_graph] || @opts[:eager]) && !opts.has_key?(:all)
+            opts = Hash[opts]
+            opts[:all] = true
+          end
+          super
         end
 
         # Do not attempt to split the result set into associations,
@@ -2596,7 +3132,7 @@ END
         def ungraphed
           ds = super.clone(:eager_graph=>nil)
           if (eg = @opts[:eager_graph]) && (rp = eg[:row_proc])
-            ds.row_proc = rp
+            ds = ds.with_row_proc(rp)
           end
           ds
         end
@@ -2614,11 +3150,16 @@ END
         # ta :: table_alias used for the parent association
         # requirements :: an array, used as a stack for requirements
         # r :: association reflection for the current association, or an SQL::AliasedExpression
-        #      with the reflection as the expression and the alias base as the aliaz.
+        #      with the reflection as the expression, the alias base as the alias (or nil to
+        #      use the default alias), and an optional hash with a :join_type entry as the columns
+        #      to use a custom join type.
         # *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.alias
+            if r.columns.is_a?(Hash)
+              join_type = r.columns[:join_type]
+            end
             r = r.expression
           else
             alias_base = r[:graph_alias_base]
@@ -2636,9 +3177,14 @@ END
           end
           local_opts = ds.opts[:eager_graph][:local]
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
-          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
+
+          if r[:conditions] && !Sequel.condition_specifier?(r[:conditions]) && !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block)
+            raise Error, "Cannot eager_graph association when :conditions specified and not a hash or an array of pairs.  Specify :graph_conditions, :graph_only_conditions, or :graph_block for the association.  Model: #{r[:model]}, association: #{r[:name]}"
+          end
+
+          ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>join_type || local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
           if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
-            ds = ds.order_more(*qualified_expression(order, assoc_table_alias))
+            ds = ds.order_append(*qualified_expression(order, assoc_table_alias))
           end
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup
@@ -2661,7 +3207,6 @@ END
         # requirements :: an array, used as a stack for requirements
         # *associations :: the associations to add to the graph
         def eager_graph_associations(ds, model, ta, requirements, *associations)
-          return ds if associations.empty?
           associations.flatten.each do |association|
             ds = case association
             when Symbol, SQL::AliasedExpression
@@ -2681,7 +3226,7 @@ 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)
-          hashes.replace(EagerGraphLoader.new(self).load(hashes))
+          hashes.replace(_eager_graph_build_associations(hashes, eager_graph_loader))
         end
       
         private
@@ -2692,12 +3237,18 @@ END
           clone(:join=>clone(:graph_from_self=>false).eager_graph_with_options(associations, :join_type=>type, :join_only=>true).opts[:join])
         end
 
+        # Process the array of hashes using the eager graph loader to return an array
+        # of model objects with the associations set.
+        def _eager_graph_build_associations(hashes, egl)
+          egl.load(hashes)
+        end
+
         # If the association has conditions itself, then it requires additional filters be
         # added to the current dataset to ensure that the passed in object would also be
         # included by the association's conditions.
         def add_association_filter_conditions(ref, obj, expr)
           if expr != SQL::Constants::FALSE && ref.filter_by_associations_add_conditions?
-            Sequel.expr(ref.filter_by_associations_conditions_expression(obj))
+            Sequel[ref.filter_by_associations_conditions_expression(obj)]
           else
             expr
           end
@@ -2725,6 +3276,7 @@ END
         # Return an expression for filtering by the given association reflection and associated object.
         def association_filter_expression(op, ref, obj)
           meth = :"#{ref[:type]}_association_filter_expression"
+          # Allow calling private association specific method to get filter expression
           send(meth, op, ref, obj) if respond_to?(meth, true)
         end
 
@@ -2776,22 +3328,37 @@ END
         # 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.alias)
+            expr = association.expression
+            if expr.is_a?(SQL::Identifier)
+              expr = expr.value
+              if expr.is_a?(String)
+                expr = expr.to_sym
+              end
+            end
+
+            SQL::AliasedExpression.new(check_association(model, expr), association.alias || expr, association.columns)
           else
             check_association(model, association)
           end
         end
       
+        # The EagerGraphLoader instance used for converting eager_graph results.
+        def eager_graph_loader
+          unless egl = cache_get(:_model_eager_graph_loader)
+            egl = cache_set(:_model_eager_graph_loader, EagerGraphLoader.new(self))
+          end
+          egl.dup
+        end
+
         # Eagerly load all specified associations 
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
-          # Key is foreign/primary key name symbol
+          # Key is foreign/primary key name symbol.
           # Value is hash with keys being foreign/primary key values (generally integers)
-          #  and values being an array of current model objects with that
-          #  specific foreign/primary key
+          # and values being an array of current model objects with that specific foreign/primary key
           key_hash = {}
           # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.collect{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
           # Populate the key_hash entry for each association being eagerly loaded
           reflections.each do |r|
@@ -2826,12 +3393,12 @@ END
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
-              associations = {}
+              associations = OPTS
             elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
               eager_block, associations = pr_assoc
             end
             loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map)
-            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} unless r[:after_load].empty?
+            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
           end 
         end
 
@@ -2887,6 +3454,10 @@ END
         end
         alias one_to_one_association_filter_expression one_to_many_association_filter_expression
 
+        def non_sql_option?(key)
+          super || key == :eager || key == :eager_graph
+        end
+
         # Build associations from the graph if #eager_graph was used, 
         # and/or load other associations if #eager was used.
         def post_load(all_records)
@@ -2916,7 +3487,6 @@ END
         # Hash with table alias symbol keys and [limit, offset] values
         attr_reader :limit_map
         
-        # Hash with table alias symbol keys and callable values used to create model instances
         # The table alias symbol for the primary model
         attr_reader :master
         
@@ -2959,19 +3529,22 @@ END
           after_load_map = @after_load_map = {}
           reflection_map.each do |k, v|
             alias_map[k] = v[:name]
-            after_load_map[k] = v[:after_load] unless v[:after_load].empty?
+            after_load_map[k] = v[:after_load] if v[:after_load]
             type_map[k] = if v.returns_array?
               true
             elsif (limit_and_offset = limit_map[k]) && !limit_and_offset.last.nil?
               :offset
             end
           end
+          after_load_map.freeze
+          alias_map.freeze
+          type_map.freeze
 
           # Make dependency map hash out of requirements array for each association.
           # This builds a tree of dependencies that will be used for recursion
           # to ensure that all parts of the object graph are loaded into the
           # appropriate subordinate association.
-          @dependency_map = {}
+          dependency_map = @dependency_map = {}
           # Sort the associations by requirements length, so that
           # requirements are added to the dependency hash before their
           # dependencies.
@@ -2987,20 +3560,14 @@ END
               hash[ta] = {}
             end
           end
+          freezer = lambda do |h|
+            h.freeze
+            h.each_value(&freezer)
+          end
+          freezer.call(dependency_map)
       
-          # This mapping is used to make sure that duplicate entries in the
-          # result set are mapped to a single record.  For example, using a
-          # single one_to_many association with 10 associated records,
-          # the main object column values appear in the object graph 10 times.
-          # We map by primary key, if available, or by the object's entire values,
-          # if not. The mapping must be per table, so create sub maps for each table
-          # alias.
-          records_map = {@master=>{}}
-          alias_map.keys.each{|ta| records_map[ta] = {}}
-          @records_map = records_map
-
           datasets = opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
-          column_aliases = opts[:graph_aliases] || opts[:graph][:column_aliases]
+          column_aliases = opts[:graph][:column_aliases]
           primary_keys = {}
           column_maps = {}
           models = {}
@@ -3024,9 +3591,9 @@ END
               h.select{|ca, c| primary_keys[ta] = ca if pk == c}
             end
           end
-          @column_maps = column_maps
-          @primary_keys = primary_keys
-          @row_procs = row_procs
+          @column_maps = column_maps.freeze
+          @primary_keys = primary_keys.freeze
+          @row_procs = row_procs.freeze
 
           # For performance, create two special maps for the master table,
           # so you can skip a hash lookup.
@@ -3038,22 +3605,35 @@ END
           # used for performance, to get all values in one hash lookup instead of
           # separate hash lookups for each data structure.
           ta_map = {}
-          alias_map.keys.each do |ta|
-            ta_map[ta] = [records_map[ta], row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]]
+          alias_map.each_key do |ta|
+            ta_map[ta] = [row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]].freeze
           end
-          @ta_map = ta_map
+          @ta_map = ta_map.freeze
+          freeze
         end
 
         # Return an array of primary model instances with the associations cache prepopulated
         # for all model objects (both primary and associated).
         def load(hashes)
+          # This mapping is used to make sure that duplicate entries in the
+          # result set are mapped to a single record.  For example, using a
+          # single one_to_many association with 10 associated records,
+          # the main object column values appear in the object graph 10 times.
+          # We map by primary key, if available, or by the object's entire values,
+          # if not. The mapping must be per table, so create sub maps for each table
+          # alias.
+          @records_map = records_map = {}
+          alias_map.keys.each{|ta| records_map[ta] = {}}
+
           master = master()
       
           # Assign to local variables for speed increase
           rp = row_procs[master]
-          rm = records_map[master]
+          rm = records_map[master] = {}
           dm = dependency_map
 
+          records_map.freeze
+
           # This will hold the final record set that we will be replacing the object graph with.
           records = []
 
@@ -3074,6 +3654,9 @@ END
           # Run after_load procs if there are any
           post_process(records, dm) if @unique || !after_load_map.empty? || !limit_map.empty?
 
+          records_map.each_value(&:freeze)
+          freeze
+
           records
         end
       
@@ -3093,7 +3676,17 @@ END
               end
               key = hkey(ta_h)
             end
-            rm, rp, assoc_name, tm, rcm = @ta_map[ta]
+            rp, assoc_name, tm, rcm = @ta_map[ta]
+            rm = records_map[ta]
+
+            # Check type map for all dependencies, and use a unique
+            # object if any are dependencies for multiple objects,
+            # to prevent duplicate objects from showing up in the case
+            # the normal duplicate removal code is not being used.
+            if !@unique && !deps.empty? && deps.any?{|dep_key,_| @ta_map[dep_key][2]}
+              key = [current.object_id, key]
+            end
+
             unless rec = rm[key]
               rec = rm[key] = rp.call(hfor(ta, h))
             end
@@ -3122,7 +3715,7 @@ END
         # Return a suitable hash key for any subhash +h+, which is an array of values by column order.
         # This is only used if the primary key cannot be used.
         def hkey(h)
-          h.sort_by{|x| x[0].to_s}
+          h.sort_by{|x| x[0]}
         end
 
         # Return the subhash for the master table by parsing the values out of the main hash +h+
@@ -3167,7 +3760,7 @@ END
           records.each do |record|
             dependency_map.each do |ta, deps|
               assoc_name = alias_map[ta]
-              list = record.send(assoc_name)
+              list = record.public_send(assoc_name)
               rec_list = if type_map[ta]
                 list.uniq!
                 if lo = limit_map[ta]