sequel 3.21.0 → 3.36.0

data/lib/sequel/plugins/many_through_many.rb

@@ -47,20 +47,18 @@ module Sequel
       class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
         Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
 
-        # The table containing the column to use for the associated key when eagerly loading
-        def associated_key_table
-          self[:associated_key_table] = self[:final_reverse_edge][:alias]
-        end
-        
         # The default associated key alias(es) to use when eager loading
         # associations via eager.
         def default_associated_key_alias
           self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
 
-        # The list of joins to use when eager graphing
-        def edges
-          self[:edges] || calculate_edges || self[:edges]
+        %w'associated_key_table eager_loading_predicate_key edges final_edge final_reverse_edge reverse_edges'.each do |meth|
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{meth}
+              cached_fetch(:#{meth}){calculate_edges[:#{meth}]}
+            end
+          END
         end
 
         # Many through many associations don't have a reciprocal
@@ -68,11 +66,6 @@ module Sequel
           nil
         end
 
-        # The list of joins to use when lazy loading or eager loading
-        def reverse_edges
-          self[:reverse_edges] || calculate_edges || self[:reverse_edges]
-        end
-
         private
 
         # Make sure to use unique table aliases when lazy loading or eager loading
@@ -109,13 +102,21 @@ module Sequel
           reverse_edges = es.reverse.map{|e| {:table=>e[:left_table], :left=>e[:left_key], :right=>e[:right_key]}}
           reverse_edges.pop
           calculate_reverse_edge_aliases(reverse_edges)
-          self[:final_edge] = edges.pop
-          self[:final_reverse_edge] = reverse_edges.pop
-          self[:edges] = edges
-          self[:reverse_edges] = reverse_edges
-          nil
+          final_reverse_edge = reverse_edges.pop
+          final_reverse_alias = final_reverse_edge[:alias]
+
+          h = {:final_edge=>edges.pop,
+               :final_reverse_edge=>final_reverse_edge,
+               :edges=>edges,
+               :reverse_edges=>reverse_edges,
+               :eager_loading_predicate_key=>qualify(final_reverse_alias, edges.first[:right]),
+               :associated_key_table=>final_reverse_edge[:alias],
+          }
+          h.each{|k, v| cached_set(k, v)}
+          h
         end
       end
+
       module ClassMethods
         # Create a many_through_many association.  Arguments:
         # * name - Same as associate, the name of the association.
@@ -174,20 +175,34 @@ module Sequel
           opts[:dataset] ||= lambda do
             ds = opts.associated_class
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-            ft = opts[:final_reverse_edge]
+            ft = opts.final_reverse_edge
             ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + left_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias])
           end
 
           left_key_alias = opts[:left_key_alias] ||= opts.default_associated_key_alias
           opts[:eager_loader] ||= lambda do |eo|
             h = eo[:key_hash][left_pk]
-            eo[:rows].each{|object| object.associations[name] = []}
+            rows = eo[:rows]
+            rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-            ft = opts[:final_reverse_edge]
-            conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
-            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + conds, :table_alias=>ft[:alias])
-            model.eager_loading_dataset(opts, ds, Array(opts.select), eo[:associations], eo).all do |assoc_record|
+            ft = opts.final_reverse_edge
+            ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.eager_loading_predicate_key, h.keys]], :table_alias=>ft[:alias])
+            ds = model.eager_loading_dataset(opts, ds, nil, eo[:associations], eo)
+            case opts.eager_limit_strategy
+            when :window_function
+              delete_rn = true
+              rn = ds.row_number_column
+              ds = apply_window_function_eager_limit_strategy(ds, opts)
+            when :correlated_subquery
+              ds = apply_correlated_subquery_eager_limit_strategy(ds, opts) do |xds|
+                dsa = ds.send(:dataset_alias, 2)
+                opts.reverse_edges.each{|t| xds = xds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
+                xds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + left_keys.map{|k| [k, SQL::QualifiedIdentifier.new(ft[:table], k)]}, :table_alias=>dsa)
+              end
+            end
+            ds.all do |assoc_record|
+              assoc_record.values.delete(rn) if delete_rn
               hash_key = if uses_lcks
                 left_key_alias.map{|k| assoc_record.values.delete(k)}
               else
@@ -196,6 +211,10 @@ module Sequel
               next unless objects = h[hash_key]
               objects.each{|object| object.associations[name].push(assoc_record)}
             end
+            if opts.eager_limit_strategy == :ruby
+              limit, offset = opts.limit_and_offset
+              rows.each{|o| o.associations[name] = o.associations[name].slice(offset||0, limit) || []}
+            end
           end
 
           join_type = opts[:graph_join_type]
@@ -204,19 +223,51 @@ module Sequel
           only_conditions = opts[:graph_only_conditions]
           use_only_conditions = opts.include?(:graph_only_conditions)
           conditions = opts[:graph_conditions]
-          opts[:eager_grapher] ||= proc do |ds, assoc_alias, table_alias|
-            iq = table_alias
+          opts[:eager_grapher] ||= proc do |eo|
+            ds = eo[:self]
+            iq = eo[:implicit_qualifier]
             opts.edges.each do |t|
               ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
               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=>assoc_alias, :join_type=>join_type, &graph_block)
+            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], :join_type=>join_type, &graph_block)
           end
 
           def_association_dataset_methods(opts)
         end
       end
+
+      module DatasetMethods
+        private
+
+        # Use a subquery to filter rows to those related to the given associated object
+        def many_through_many_association_filter_expression(op, ref, obj)
+          lpks = ref[:left_primary_keys]
+          lpks = lpks.first if lpks.length == 1
+          lpks = ref.qualify(model.table_name, lpks)
+          edges = ref.edges
+          first, rest = edges.first, edges[1..-1]
+          last = edges.last
+          ds = model.db[first[:table]].select(*Array(ref.qualify(first[:table], first[:right])))
+          rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), &e[:block])}
+          last_alias = if rest.empty?
+            first[:table]
+          else
+            last_join = ds.opts[:join].last
+            last_join.table_alias || last_join.table
+          end
+          meths = ref.right_primary_keys
+          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+          exp = association_filter_key_expression(ref.qualify(last_alias, Array(ref.final_edge[:left])), meths, obj)
+          if exp == SQL::Constants::FALSE
+            association_filter_handle_inversion(op, exp, Array(lpks))
+          else
+            ds = ds.where(exp).exclude(SQL::BooleanExpression.from_value_pairs(ds.opts[:select].zip([]), :OR))
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>ds), Array(lpks))
+          end
+        end
+      end
     end
   end
 end

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -0,0 +1,71 @@
+module Sequel
+  module Plugins
+    # This is a fairly simple plugin that modifies the internal association loading logic
+    # for many_to_one associations to use a simple primary key lookup on the associated
+    # class, which is generally faster as it uses mostly static SQL.  Additional, if the
+    # associated class is caching primary key lookups, you get the benefit of a cached
+    # lookup.
+    #
+    # This plugin is generally not as fast as the prepared_statements_associations plugin
+    # in the case where the model is not caching primary key lookups, however, it is
+    # probably significantly faster if the model is caching primary key lookups.  If
+    # the prepared_statements_associations plugin has been loaded first, this
+    # plugin will only use the primary key lookup code if the associated model is
+    # caching primary key lookups.
+    #
+    # This plugin attempts to determine cases where the primary key lookup would have
+    # different results than the regular lookup, and use the regular lookup in that case,
+    # but it cannot handle all situations correctly, which is why it is not Sequel's
+    # default behavior.
+    #
+    # You can disable primary key lookups on a per association basis with this
+    # plugin using the :many_to_one_pk_lookup=>false association option.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances use primary key lookups for many_to_one
+    #   # association loading
+    #   Sequel::Model.plugin :many_to_one_pk_lookup
+    #
+    #   # Do so for just the album class.
+    #   Album.plugin :many_to_one_pk_lookup
+    module ManyToOnePkLookup
+      module InstanceMethods
+        private
+
+        # If the current association is a fairly simple many_to_one association, use
+        # a simple primary key lookup on the associated model, which can benefit from
+        # caching if the associated model is using caching.
+        def _load_associated_object(opts, dynamic_opts)
+          klass = opts.associated_class
+          cache_lookup = opts.send(:cached_fetch, :many_to_one_pk_lookup) do 
+            opts[:type] == :many_to_one &&
+              opts[:key] &&
+              opts.primary_key == klass.primary_key
+          end
+          if cache_lookup &&
+            !dynamic_opts[:callback] &&
+            (o = klass.send(:primary_key_lookup, ((fk = opts[:key]).is_a?(Array) ? fk.map{|c| send(c)} : send(fk))))
+            o
+          else
+            super
+          end
+        end
+
+        # Deal with the situation where the prepared_statements_associations plugin is
+        # loaded first, by using a primary key lookup for many_to_one associations if
+        # the associated class is using caching, and using the default code otherwise.
+        # This is done because the prepared_statements_associations code is probably faster
+        # than the primary key lookup this plugin uses if the model is not caching lookups,
+        # but probably slower if the model is caching lookups.
+        def _load_associated_objects(opts, dynamic_opts={})
+          if opts.can_have_associated_objects?(self) && opts[:type] == :many_to_one && opts.associated_class.respond_to?(:cache_get_pk)
+            _load_associated_object(opts, dynamic_opts)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/nested_attributes.rb

@@ -1,20 +1,75 @@
 module Sequel
   module Plugins
-    # The nested_attributes plugin allows you to update attributes for associated
-    # objects directly through the parent object, similar to ActiveRecord's
-    # Nested Attributes feature.
-    #
-    # Nested attributes are created using the nested_attributes method:
+    # The nested_attributes plugin allows you to create, update, and delete
+    # associated objects directly by calling a method on the current object.
+    # Nested attributes are defined using the nested_attributes class method:
     #
     #   Artist.one_to_many :albums
     #   Artist.plugin :nested_attributes
     #   Artist.nested_attributes :albums
-    #   a = Artist.new(:name=>'YJM',
-    #    :albums_attributes=>[{:name=>'RF'}, {:name=>'MO'}])
-    #   # No database activity yet
     #
-    #   a.save # Saves artist and both albums
-    #   a.albums.map{|x| x.name} # ['RF', 'MO']
+    # 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')
+    #
+    # You can create new album instances related to this artist:
+    #
+    #   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:
+    #
+    #   a.save
+    #
+    # That will save the artist first, and then save both albums.  If either the artist
+    # is invalid or one of the albums is invalid, none of the objects will be saved to the
+    # database, and all related validation errors will be available in the artist's validation
+    # errors.
+    #
+    # In addition to creating new associated objects, you can also update existing associated
+    # 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'}])
+    #
+    # Since the primary key field is filled in, the plugin will update the album with id 1 instead
+    # of creating a new album.
+    #
+    # If you would like to delete the associated object instead of updating it, you add a _delete
+    # entry to the hash:
+    #
+    #   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:
+    #
+    #   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
+    # pass a single hash instead of an array of hashes.
+    #
+    # This plugin is mainly designed to make it easy to use on html forms, where a single form
+    # submission can contained nested attributes (and even nested attributes of those attributes).
+    # You just need to name your form inputs correctly:
+    #
+    #   artist[name]
+    #   artist[albums_attributes][0][:name]
+    #   artist[albums_attributes][1][:id]
+    #   artist[albums_attributes][1][:name]
+    #
+    # Your web stack will probably parse that into a nested hash similar to:
+    #
+    #   {:artist=>{:name=>?, :albums_attributes=>{0=>{:name=>?}, 1=>{:id=>?, :name=>?}}}}
+    #
+    # Then you can do:
+    #
+    #   artist.update(params[:artist])
+    #
+    # To save changes to the artist, create the first album and associate it to the artist,
+    # and update the other existing associated album.
     module NestedAttributes
       # Depend on the instance_hooks plugin.
       def self.apply(model)
@@ -32,20 +87,30 @@ module Sequel
         #   modified through the association_attributes= method to the specific fields given.
         # * :limit - For *_to_many associations, a limit on the number of records
         #   that will be processed, to prevent denial of service attacks.
+        # * :reject_if - A proc that is given each attribute hash before it is
+        #   passed to its associated object. If the proc returns a truthy
+        #   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).
-        # * :strict - Set to false to not raise an error message if a primary key
-        #   is provided in a record, but it doesn't match an existing associated
-        #   object.
+        # * :strict - Kept for backward compatibility. Setting it to false is
+        #   equivalent to setting :unmatched_pk to :ignore.
+        # * :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.
+        # * :unmatched_pk - Specify the action to be taken if a primary key is
+        #   provided in a record, but it doesn't match an existing associated
+        #   object. Set to :create to create a new object with that primary
+        #   key, :ignore to ignore the record, or :raise to raise an error.
+        #   The default is :raise.
         #
-        # If a block is provided, it is passed each nested attribute hash.  If
-        # the hash should be ignored, the block should return anything except false or nil.
+        # 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 : {}
           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][:reject_if] ||= block
             def_nested_attribute_method(r)
           end
@@ -78,7 +143,9 @@ module Sequel
         def nested_attributes_check_key_modifications(reflection, obj)
           keys = reflection.associated_object_keys.map{|x| obj.send(x)}
           yield
-          raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed") unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+          unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
+            raise(Error, "Modifying association dependent key(s) when updating associated objects is not allowed")
+          end
         end
         
         # Create a new associated object with the given attributes, validate
@@ -93,6 +160,12 @@ module Sequel
             after_save_hook{send(reflection.add_method, obj)}
           else
             associations[reflection[:name]] = obj
+
+            # Because we are modifying the associations cache manually before the
+            # setter is called, we still want to run the setter code even though
+            # the cached value will be the same as the given value.
+            @set_associated_object_if_same = true
+
             # 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.
             send(reflection[:type] == :many_to_one ? :before_save_hook : :after_save_hook){send(reflection.setter_method, obj.save(:validate=>false))}
@@ -100,16 +173,6 @@ module Sequel
           obj
         end
         
-        # Find an associated object with the matching pk.  If a matching option
-        # is not found and the :strict option is not false, raise an Error.
-        def nested_attributes_find(reflection, pk)
-          pk = pk.to_s
-          unless obj = Array(associated_objects = send(reflection[:name])).find{|x| x.pk.to_s == pk}
-            raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})") unless reflection[:nested_attributes][:strict] == false
-          end
-          obj
-        end
-        
         # Take an array or hash of attribute hashes and set each one individually.
         # If a hash is provided it, sort it by key and then use the values.
         # If there is a limit on the nested attributes for this association,
@@ -122,24 +185,22 @@ module Sequel
           attributes_list.each{|a| nested_attributes_setter(reflection, a)}
         end
         
-        # Remove the matching associated object from the current object.
-        # If the :destroy option is given, destroy the object after disassociating it
+        # Remove the given associated object from the current object. If the
+        # :destroy option is given, destroy the object after disassociating it
         # (unless destroying the object would automatically disassociate it).
-        # Returns the object removed, if it exists.
-        def nested_attributes_remove(reflection, pk, opts={})
-          if obj = nested_attributes_find(reflection, pk)
-            if !opts[:destroy] || reflection.remove_before_destroy?
-              before_save_hook do
-                if reflection.returns_array?
-                  send(reflection.remove_method, obj)
-                else
-                  send(reflection.setter_method, nil)
-                end
+        # Returns the object removed.
+        def nested_attributes_remove(reflection, obj, opts={})
+          if !opts[:destroy] || reflection.remove_before_destroy?
+            before_save_hook do
+              if reflection.returns_array?
+                send(reflection.remove_method, obj)
+              else
+                send(reflection.setter_method, nil)
               end
             end
-            after_save_hook{obj.destroy} if opts[:destroy]
-            obj
           end
+          after_save_hook{obj.destroy} if opts[:destroy]
+          obj
         end
         
         # Set the fields in the obj based on the association, only allowing
@@ -152,42 +213,57 @@ module Sequel
           end
         end
 
-        # Modify the associated object based on the contents of the attribtues hash:
+        # Modify the associated object based on the contents of the attributes hash:
+        # * If a :transform block was given to nested_attributes, use it to modify the attribute hash.
         # * If a block was given to nested_attributes, call it with the attributes and return immediately if the block returns true.
+        # * If a primary key exists in the attributes hash and it matches an associated object:
+        # ** If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
+        # ** If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
+        # ** Otherwise, update the matching associated object with the contents of the hash.
+        # * If a primary key exists in the attributes hash but it does not match an associated object,
+        #   either raise an error, create a new object or ignore the hash, depending on the :unmatched_pk option.
         # * If no primary key exists in the attributes hash, create a new object.
-        # * If _delete is a key in the hash and the :destroy option is used, destroy the matching associated object.
-        # * If _remove is a key in the hash and the :remove option is used, disassociated the matching associated object.
-        # * Otherwise, update the matching associated object with the contents of the hash.
         def nested_attributes_setter(reflection, attributes)
+          if a = reflection[:nested_attributes][:transform]
+            attributes = a.call(self, attributes)
+          end
           return if (b = reflection[:nested_attributes][:reject_if]) && b.call(attributes)
           modified!
           klass = reflection.associated_class
-          if pk = attributes.delete(klass.primary_key) || attributes.delete(klass.primary_key.to_s)
-            if klass.db.send(:typecast_value_boolean, attributes[:_delete] || attributes['_delete']) && reflection[:nested_attributes][:destroy]
-              nested_attributes_remove(reflection, pk, :destroy=>true)
-            elsif klass.db.send(:typecast_value_boolean, attributes[:_remove] || attributes['_remove']) && reflection[:nested_attributes][:remove]
-              nested_attributes_remove(reflection, pk)
+          sym_keys = Array(klass.primary_key)
+          str_keys = sym_keys.map{|k| k.to_s}
+          if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
+            pk = pk.map{|k| k.to_s}
+            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map{|k| k.to_s} == pk}
+          end
+          if obj
+            attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
+            if reflection[:nested_attributes][:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
+              nested_attributes_remove(reflection, obj, :destroy=>true)
+            elsif reflection[:nested_attributes][:remove] && klass.db.send(:typecast_value_boolean, attributes.delete(:_remove) || attributes.delete('_remove'))
+              nested_attributes_remove(reflection, obj)
             else
-              nested_attributes_update(reflection, pk, attributes)
+              nested_attributes_update(reflection, obj, attributes)
+            end
+          elsif pk.all? && reflection[:nested_attributes][:unmatched_pk] != :create
+            if reflection[:nested_attributes][:unmatched_pk] == :raise
+              raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})")
             end
           else
             nested_attributes_create(reflection, attributes)
           end
         end
         
-        # Update the matching associated object with the attributes,
-        # validating it when the parent object is validated and saving it
-        # when the parent is saved.
-        # Returns the object updated, if it exists.
-        def nested_attributes_update(reflection, pk, attributes)
-          if obj = nested_attributes_find(reflection, pk)
-            nested_attributes_update_attributes(reflection, obj, attributes)
-            after_validation_hook{validate_associated_object(reflection, obj)}
-            # 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.
-            after_save_hook{obj.save_changes(:validate=>false)}
-            obj
-          end
+        # Update the given object with the attributes, validating it when the
+        # parent object is validated and saving it when the parent is saved.
+        # Returns the object updated.
+        def nested_attributes_update(reflection, obj, attributes)
+          nested_attributes_update_attributes(reflection, obj, attributes)
+          after_validation_hook{validate_associated_object(reflection, obj)}
+          # 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.
+          after_save_hook{obj.save_changes(:validate=>false)}
+          obj
         end
 
         # Update the attributes for the given object related to the current object through the association.

data/lib/sequel/plugins/optimistic_locking.rb

@@ -65,6 +65,14 @@ module Sequel
           lc = model.lock_column
           instance_filter(lc=>send(lc))
         end
+
+        # Clear the instance filters when refreshing, so that attempting to
+        # refresh after a failed save removes the previous lock column filter
+        # (the new one will be added before updating).
+        def _refresh(ds)
+          clear_instance_filters
+          super
+        end
         
         # Only update the row if it has the same lock version, and increment the
         # lock version.