sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/lazy_attributes.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The lazy_attributes plugin allows users to easily set that some attributes
@@ -11,7 +13,7 @@ module Sequel
     # get the reviews for all of those albums:
     #
     #   Album.plugin :lazy_attributes, :review
-    #   Album.filter{id<100}.all do |a|
+    #   Album.where{id < 100}.all do |a|
     #     a.review
     #   end
     #
@@ -36,9 +38,12 @@ module Sequel
       end
       
       module ClassMethods
-        # Module to store the lazy attribute getter methods, so they can
-        # be overridden and call super to get the lazy attribute behavior
-        attr_accessor :lazy_attributes_module
+        # Freeze lazy attributes module when freezing model class.
+        def freeze
+          @lazy_attributes_module.freeze if @lazy_attributes_module
+
+          super
+        end
 
         # Remove the given attributes from the list of columns selected by default.
         # For each attribute given, create an accessor method that allows a lazy
@@ -57,8 +62,8 @@ module Sequel
         # :dataset :: The base dataset to use for the lazy attribute lookup
         # :table :: The table name to use to qualify the attribute and primary key columns.
         def define_lazy_attribute_getter(a, opts=OPTS)
-          include(self.lazy_attributes_module ||= Module.new) unless lazy_attributes_module
-          lazy_attributes_module.class_eval do
+          include(@lazy_attributes_module ||= Module.new) unless @lazy_attributes_module
+          @lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.has_key?(a) && !new?
                 lazy_attribute_lookup(a, opts)
@@ -78,9 +83,8 @@ module Sequel
         # the attribute for just the current object.  Return the value of
         # the attribute for the current object.
         def lazy_attribute_lookup(a, opts=OPTS)
-          unless table = opts[:table]
-            table = model.table_name
-          end
+          table = opts[:table] || model.table_name
+          selection = Sequel.qualify(table, a)
 
           if base_ds = opts[:dataset]
             ds = base_ds.where(qualified_pk_hash(table))
@@ -89,19 +93,21 @@ module Sequel
             ds = this
           end
 
-          selection = Sequel.qualify(table, a)
-
           if frozen?
-            return ds.dup.get(selection)
+            return ds.get(selection)
           end
 
           if retrieved_with
-            raise(Error, "Invalid primary key column for #{model}: #{pkc.inspect}") unless primary_key = model.primary_key
+            primary_key = model.primary_key
             composite_pk = true if primary_key.is_a?(Array)
             id_map = {}
             retrieved_with.each{|o| id_map[o.pk] = o unless o.values.has_key?(a) || o.frozen?}
             predicate_key = composite_pk ? primary_key.map{|k| Sequel.qualify(table, k)} : Sequel.qualify(table, primary_key)
-            base_ds.select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).where(predicate_key=>id_map.keys).naked.each do |row|
+            base_ds.
+             select(*(Array(primary_key).map{|k| Sequel.qualify(table, k)} + [selection])).
+             where(predicate_key=>id_map.keys).
+             naked.
+             each do |row|
               obj = id_map[composite_pk ? row.values_at(*primary_key) : row[primary_key]]
               if obj && !obj.values.has_key?(a)
                 obj.values[a] = row[a]

data/lib/sequel/plugins/list.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The list plugin allows for model instances to be part of an ordered list,
@@ -9,7 +11,7 @@ module Sequel
     #
     #   class Item < Sequel::Model(:items)
     #     plugin :list # will use :position field for position
-    #     plugin :list, :field=>:pos # will use :pos field for position
+    #     plugin :list, field: :pos # will use :pos field for position
     #   end
     #   
     #   item = Item[1]
@@ -36,34 +38,41 @@ module Sequel
     # For example, if each item has a +user_id+ field, and you want every user
     # to have their own list:
     #
-    #   Item.plugin :list, :scope=>:user_id
+    #   Item.plugin :list, scope: :user_id
     # 
     # Note that using this plugin modifies the order of the model's dataset to
     # sort by the position and scope fields.  Also note that this plugin is subject to
     # race conditions, and is not safe when concurrent modifications are made
     # to the same list.
     #
-    # Additionally, note that unlike ruby arrays, the list plugin assumes that the
-    # first entry in the list has position 1, not position 0.
+    # Note that by default, unlike ruby arrays, the list plugin assumes the first
+    # entry in the list has position 1, not position 0.
+    #
+    # You can change this by providing an integer <tt>:top</tt> option:
+    #
+    #   Item.plugin :list, top: 0
     #
     # Copyright (c) 2007-2010 Sharon Rosner, Wayne E. Seguin, Aman Gupta, Adrian Madrid, Jeremy Evans
     module List
-      # Set the +position_field+ and +scope_proc+ attributes for the model,
-      # using the <tt>:field</tt> and <tt>:scope</tt> options, respectively.
+      # Set the +position_field+, +scope_proc+ and +top_of_list+ attributes for the model,
+      # using the <tt>:field</tt>, <tt>:scope</tt>, and <tt>:top</tt> options, respectively.
       # The <tt>:scope</tt> option can be a symbol, array of symbols, or a proc that
       # accepts a model instance and returns a dataset representing the list.
       # Also, modify the model dataset's order to order by the position and scope fields.
       def self.configure(model, opts = OPTS)
         model.position_field = opts[:field] || :position
         model.dataset = model.dataset.order_prepend(model.position_field)
+        model.instance_exec do
+          @top_of_list = opts[:top] || 1
+        end
         
         model.scope_proc = case scope = opts[:scope]
         when Symbol
           model.dataset = model.dataset.order_prepend(scope)
-          proc{|obj| obj.model.filter(scope=>obj.send(scope))}
+          proc{|obj| obj.model.where(scope=>obj.public_send(scope))}
         when Array
           model.dataset = model.dataset.order_prepend(*scope)
-          proc{|obj| obj.model.filter(scope.map{|s| [s, obj.get_column_value(s)]})}
+          proc{|obj| obj.model.where(scope.map{|s| [s, obj.get_column_value(s)]})}
         else
           scope
         end
@@ -78,7 +87,10 @@ module Sequel
         # proc should accept an instance and return a dataset representing the list.
         attr_accessor :scope_proc
 
-        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil)
+        # An Integer to use as the position of the top of the list. Defaults to 1.
+        attr_reader :top_of_list
+
+        Plugins.inherited_instance_variables(self, :@position_field=>nil, :@scope_proc=>nil, :@top_of_list=>nil)
       end
 
       module InstanceMethods
@@ -87,21 +99,12 @@ module Sequel
           list_dataset.first(position_field => p)
         end
 
-        # Set the value of the position_field to the maximum value plus 1 unless the
-        # position field already has a value.
-        def before_create
-          unless get_column_value(position_field)
-            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
-          end
-          super
-        end
-
         # When destroying an instance, move all entries after the instance down
         # one position, so that there aren't any gaps
         def after_destroy
           super
 
-          f = Sequel.expr(position_field)
+          f = Sequel[position_field]
           list_dataset.where(f > position_value).update(f => f - 1)
         end
 
@@ -121,20 +124,22 @@ module Sequel
           move_to(position_value + n)
         end
 
-        # Move this instance to the given place in the list.  Raises an
-        # exception if target is less than 1 or greater than the last position in the list.
+        # Move this instance to the given place in the list.  If lp is not
+        # given or greater than the last list position, uses the last list
+        # position.  If lp is less than the top list position, uses the
+        # top list position.
         def move_to(target, lp = nil)
           current = position_value
           if target != current
             checked_transaction do
               ds = list_dataset
               op, ds = if target < current
-                target = 1 if target < 1
-                [:+, ds.filter(position_field=>target...current)]
+                target = model.top_of_list if target < model.top_of_list
+                [:+, ds.where(position_field=>target...current)]
               else
                 lp ||= last_position
                 target = lp if target > lp
-                [:-, ds.filter(position_field=>(current + 1)..target)]
+                [:-, ds.where(position_field=>(current + 1)..target)]
               end
               ds.update(position_field => Sequel::SQL::NumericExpression.new(op, position_field, 1))
               update(position_field => target)
@@ -149,9 +154,9 @@ module Sequel
           move_to(lp, lp)
         end
 
-        # Move this instance to the top (first position, position 1) of the list.
+        # Move this instance to the top (first position, usually position 1) of the list.
         def move_to_top
-          move_to(1)
+          move_to(model.top_of_list)
         end
 
         # Move this instance the given number of places up in the list, or 1 place
@@ -177,6 +182,15 @@ module Sequel
           self.next(n * -1)
         end
 
+        # Set the value of the position_field to the maximum value plus 1 unless the
+        # position field already has a value.
+        def before_validation
+          unless get_column_value(position_field)
+            set_column_value("#{position_field}=", list_dataset.max(position_field).to_i+1)
+          end
+          super
+        end
+
         private
 
         # The model's position field, an instance method for ease of use.

data/lib/sequel/plugins/many_through_many.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The many_through_many plugin allow you to create an association using multiple join tables.
@@ -44,18 +46,18 @@ module Sequel
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]]
     #
     #   # All albums by artists that are associated to any album that this artist is associated to
-    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], \
-    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]], \
-    #    :class=>:Album
+    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id],
+    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]],
+    #    class: :Album
     #
     #   # All tracks on albums by this artist (also could be a many_to_many)
-    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]], \
-    #    :right_primary_key=>:album_id
+    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]],
+    #    right_primary_key: :album_id
     #
     # Often you don't want the current object to appear in the array of associated objects.  This is easiest to handle via an :after_load hook:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]],
-    #     :after_load=>proc{|artist, associated_artists| associated_artists.delete(artist)}
+    #     after_load: lambda{|artist, associated_artists| associated_artists.delete(artist)}
     #
     # You can also handle it by adding a dataset block that excludes the current record (so it won't be retrieved at all), but
     # that won't work when eagerly loading, which is why the :after_load proc is recommended instead.
@@ -63,7 +65,7 @@ module Sequel
     # It's also common to not want duplicate records, in which case the :distinct option can be used:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]],
-    #    :distinct=>true
+    #    distinct: true
     # 
     # In addition to many_through_many, this plugin also adds one_through_many, for an association to a single object through multiple join tables.
     # This is useful if there are unique constraints on the foreign keys in the join tables that reference back to the current table, or if you want
@@ -79,7 +81,7 @@ module Sequel
     module ManyThroughMany
       # The AssociationReflection subclass for many_through_many associations.
       class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self}
 
         # many_through_many and one_through_many associations can be clones
         def cloneable?(ref)
@@ -100,6 +102,17 @@ module Sequel
           END
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :associated_key_table=>:associated_key_table,
+          :edges=>:edges,
+          :final_edge=>:final_edge,
+          :final_reverse_edge=>:final_reverse_edge,
+          :reverse_edges=>:reverse_edges
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # The alias for the first join table.
         def join_table_alias
           final_reverse_edge[:alias]
@@ -131,7 +144,7 @@ module Sequel
             table_alias = e[:table]
             if aliases.include?(table_alias)
               i = 0
-              table_alias = loop do
+              table_alias = while true
                 ta = :"#{table_alias}_#{i}"
                 break ta unless aliases.include?(ta)
                 i += 1
@@ -179,7 +192,7 @@ module Sequel
       end
 
       class OneThroughManyAssociationReflection < ManyThroughManyAssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:one_through_many] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:one_through_many] = self}
         include Sequel::Model::Associations::SingularAssociationReflection
       end
 
@@ -215,7 +228,10 @@ module Sequel
         def def_many_through_many(opts)
           one_through_many = opts[:type] == :one_through_many
           opts[:read_only] = true
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
           opts[:through] = opts[:through].map do |e|
             case e
@@ -270,7 +286,7 @@ module Sequel
                 iq = nil
               end
               fe = opts.final_edge
-              ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
+              ds.graph(opts.associated_class.dataset, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :qualify=>:deep, :join_type=>eo[:join_type]||join_type, :join_only=>eo[:join_only], &graph_block)
             end
           end
         end

data/lib/sequel/plugins/modification_detection.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # This plugin automatically detects in-place modifications to
@@ -15,6 +17,9 @@ module Sequel
     # Note that for this plugin to work correctly, the column values must
     # correctly implement the #hash method, returning the same value if
     # the object is equal, and a different value if the object is not equal.
+    # As this solely uses hash values to check for modification, there may
+    # be cases where a modification is made and the hash value is the same,
+    # resulting in a false negative.
     #
     # Note that this plugin causes a performance hit for all retrieved
     # objects, so it shouldn't be used in cases where performance is a
@@ -53,13 +58,20 @@ module Sequel
         # Detect which columns have been modified by comparing the cached hash
         # value to the hash of the current value.
         def changed_columns
-          cc = super
-          changed = []
-          v = @values
+          changed = super
           if vh = @values_hashes
-            (vh.keys - cc).each{|c| changed << c unless v.has_key?(c) && vh[c] == v[c].hash}
+            values = @values
+            changed = changed.dup if frozen?
+            vh.each do |c, v|
+              match = values.has_key?(c) && v == values[c].hash
+              if changed.include?(c)
+                changed.delete(c) if match
+              else
+                changed << c unless match
+              end
+            end
           end
-          cc + changed
+          changed
         end
 
         private

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # This plugin implements optimistic locking mechanism on Microsoft SQL Server
@@ -10,15 +12,15 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::NoExistingObject
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # In order for this plugin to work, you need to make sure that the database
     # table has a column of timestamp or rowversion.  The plugin uses a default
     # name of timestamp for this columns, but you can override that using the
     # :lock_column option:
     #
-    #     plugin :mssql_optimistic_locking, :lock_column=>:column_name
+    #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking
@@ -73,7 +75,8 @@ module Sequel
         # it to be assigned.
         def _save_update_all_columns_hash
           v = @values.dup
-          Array(primary_key).each{|x| v.delete(x) unless changed_columns.include?(x)}
+          cc = changed_columns
+          Array(primary_key).each{|x| v.delete(x) unless cc.include?(x)}
           v.delete(model.lock_column)
           v
         end
@@ -82,7 +85,7 @@ module Sequel
         def _update_without_checking(columns)
           ds = _update_dataset
           lc = model.lock_column
-          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel.qualify(:inserted, lc)]).update_sql(columns))).all
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel[:inserted][lc]]).update_sql(columns))).all
           values[lc] = rows.first[lc] unless rows.empty?
           rows.length
         end

data/lib/sequel/plugins/nested_attributes.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The nested_attributes plugin allows you to create, update, and delete
@@ -11,11 +13,11 @@ module Sequel
     # The nested_attributes call defines a single method, <tt><i>association</i>_attributes=</tt>,
     # (e.g. <tt>albums_attributes=</tt>).  So if you have an Artist instance:
     #
-    #   a = Artist.new(:name=>'YJM')
+    #   a = Artist.new(name: 'YJM')
     #
     # You can create new album instances related to this artist:
     #
-    #   a.albums_attributes = [{:name=>'RF'}, {:name=>'MO'}]
+    #   a.albums_attributes = [{name: 'RF'}, {name: 'MO'}]
     #
     # Note that this doesn't send any queries to the database yet.  That doesn't happen till
     # you save the object:
@@ -31,7 +33,7 @@ module Sequel
     # objects.  You just need to make sure that the primary key field is filled in for the
     # associated object:
     #
-    #   a.update(:albums_attributes => [{:id=>1, :name=>'T'}])
+    #   a.update(:albums_attributes => [{id: 1, name: 'T'}])
     #
     # Since the primary key field is filled in, the plugin will update the album with id 1 instead
     # of creating a new album.
@@ -39,15 +41,15 @@ module Sequel
     # If you would like to delete the associated object instead of updating it, you add a _delete
     # entry to the hash, and also pass the :destroy option when calling +nested_attributes+:
     #
-    #   Artist.nested_attributes :albums, :destroy=>true
-    #   a.update(:albums_attributes => [{:id=>1, :_delete=>true}])
+    #   Artist.nested_attributes :albums, destroy: true
+    #   a.update(:albums_attributes => [{id: 1, _delete: true}])
     #
     # This will delete the related associated object from the database.  If you want to leave the
     # associated object in the database, but just remove it from the association, add a _remove
     # entry in the hash, and also pass the :remove option when calling +nested_attributes+:
     #
-    #   Artist.nested_attributes :albums, :remove=>true
-    #   a.update(:albums_attributes => [{:id=>1, :_remove=>true}])
+    #   Artist.nested_attributes :albums, remove: true
+    #   a.update(:albums_attributes => [{id: 1, _remove: true}])
     #
     # The above example was for a one_to_many association, but the plugin also works similarly
     # for other association types.  For one_to_one and many_to_one associations, you need to
@@ -64,14 +66,25 @@ module Sequel
     #
     # Your web stack will probably parse that into a nested hash similar to:
     #
-    #   {:artist=>{:name=>'Y', :albums_attributes=>{0=>{:name=>'X'}, 1=>{:id=>'2', :name=>'Z'}}}}
+    #   {'artist'=>{'name'=>'Y', 'albums_attributes'=>{'0'=>{'name'=>'X'}, '1'=>{'id'=>'2', 'name'=>'Z'}}}}
     #
     # Then you can do:
     #
-    #   artist.update(params[:artist])
+    #   artist.update_fields(params['artist'], %w'name albums_attributes')
+    #
+    # Note that Rails 5+ does not use a Hash for submitted parameters, and therefore
+    # the above will not work.  With Rails 5+, you have to use:
+    #
+    #   artist.update_fields(params.to_unsafe_h['artist'], %w'name albums_attributes')
     #
     # To save changes to the artist, create the first album and associate it to the artist,
     # and update the other existing associated album.
+    #
+    # You can pass options for individual nested attributes, which will override the default
+    # nested attributes options for that association.  This is useful for per-call filtering
+    # of the allowed fields:
+    #
+    #   a.set_nested_attributes(:albums, params['artist'], :fields=>%w'name')
     module NestedAttributes
       # Depend on the validate_associated plugin.
       def self.apply(model)
@@ -79,10 +92,13 @@ module Sequel
       end
       
       module ClassMethods
-        # Module to store the nested_attributes setter methods, so they can
-        # call be overridden and call super to get the default behavior
-        attr_accessor :nested_attributes_module
-        
+        # Freeze nested_attributes_module when freezing model class.
+        def freeze
+          @nested_attributes_module.freeze if @nested_attributes_module
+
+          super
+        end
+
         # Allow nested attributes to be set for the given associations.  Options:
         # :destroy :: Allow destruction of nested records.
         # :fields :: If provided, should be an Array or proc. If it is an array,
@@ -97,6 +113,10 @@ module Sequel
         #               value, the attribute hash is ignored.
         # :remove :: Allow disassociation of nested records (can remove the associated
         #            object from the parent object, but not destroy the associated object).
+        # :require_modification :: Whether to require modification of nested objects when
+        #                          updating or deleting them (checking that a single row was
+        #                          updated).  By default, uses the default require_modification
+        #                          setting for the nested object.
         # :transform :: A proc to transform attribute hashes before they are
         #               passed to associated object. Takes two arguments, the parent object and
         #               the attribute hash. Uses the return value as the new attribute hash.
@@ -108,12 +128,12 @@ module Sequel
         #
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
-          include(self.nested_attributes_module ||= Module.new) unless nested_attributes_module
-          opts = associations.last.is_a?(Hash) ? associations.pop : {}
+          include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
+          opts = associations.last.is_a?(Hash) ? associations.pop : OPTS
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
-            r[:nested_attributes] = opts
-            r[:nested_attributes][:unmatched_pk] ||= opts.delete(:strict) == false ? :ignore : :raise
+            r[:nested_attributes] = opts.dup
+            r[:nested_attributes][:unmatched_pk] ||= :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
           end
@@ -124,7 +144,7 @@ module Sequel
         # Add a nested attribute setter method to a module included in the
         # class.
         def def_nested_attribute_method(reflection)
-          nested_attributes_module.class_eval do
+          @nested_attributes_module.class_eval do
             define_method("#{reflection[:name]}_attributes=") do |v|
               set_nested_attributes(reflection[:name], v)
             end
@@ -139,7 +159,7 @@ module Sequel
         def set_nested_attributes(assoc, obj, opts=OPTS)
           raise(Error, "no association named #{assoc} for #{model.inspect}") unless ref = model.association_reflection(assoc)
           raise(Error, "nested attributes are not enabled for association #{assoc} for #{model.inspect}") unless meta = ref[:nested_attributes]
-          meta = Hash[meta].merge!(opts)
+          meta = meta.merge(opts)
           meta[:reflection] = ref
           if ref.returns_array?
             nested_attributes_list_setter(meta, obj)
@@ -170,8 +190,9 @@ module Sequel
           nested_attributes_set_attributes(meta, obj, attributes)
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
-            send(reflection[:name]) << obj
-            after_save_hook{send(reflection.add_method, obj)}
+            public_send(reflection[:name]) << obj
+            obj.skip_validation_on_next_save!
+            after_save_hook{public_send(reflection[:add_method], obj)}
           else
             associations[reflection[:name]] = obj
 
@@ -183,9 +204,12 @@ module Sequel
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
             if reflection[:type] == :many_to_one 
-              before_save_hook{send(reflection.setter_method, obj.save(:validate=>false))}
+              before_save_hook{public_send(reflection[:setter_method], obj.save(:validate=>false))}
             else
-              after_save_hook{send(reflection.setter_method, obj)}
+              after_save_hook do
+                obj.skip_validation_on_next_save!
+                public_send(reflection[:setter_method], obj)
+              end
             end
           end
           add_reciprocal_object(reflection, obj)
@@ -197,7 +221,7 @@ module Sequel
         # If there is a limit on the nested attributes for this association,
         # make sure the length of the attributes_list is not greater than the limit.
         def nested_attributes_list_setter(meta, attributes_list)
-          attributes_list = attributes_list.sort_by(&:to_s).map{|k,v| v} if attributes_list.is_a?(Hash)
+          attributes_list = attributes_list.sort.map{|k,v| v} if attributes_list.is_a?(Hash)
           if (limit = meta[:limit]) && attributes_list.length > limit
             raise(Error, "number of nested attributes (#{attributes_list.length}) exceeds the limit (#{limit})")
           end
@@ -213,9 +237,9 @@ module Sequel
           if !opts[:destroy] || reflection.remove_before_destroy?
             before_save_hook do
               if reflection.returns_array?
-                send(reflection.remove_method, obj)
+                public_send(reflection[:remove_method], obj)
               else
-                send(reflection.setter_method, nil)
+                public_send(reflection[:setter_method], nil)
               end
             end
           end
@@ -231,7 +255,7 @@ module Sequel
         def nested_attributes_set_attributes(meta, obj, attributes)
           if fields = meta[:fields]
             fields = fields.call(obj) if fields.respond_to?(:call)
-            obj.set_only(attributes, fields)
+            obj.set_fields(attributes, fields, :missing=>:skip)
           else
             obj.set(attributes)
           end
@@ -259,9 +283,12 @@ module Sequel
           str_keys = sym_keys.map(&:to_s)
           if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
             pk = pk.map(&:to_s)
-            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
+            obj = Array(public_send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
+            unless (require_modification = meta[:require_modification]).nil?
+              obj.require_modification = require_modification
+            end
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
             if meta[:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
               nested_attributes_remove(meta, obj, :destroy=>true)