sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/nested_attributes.rb

@@ -13,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:
@@ -33,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.
@@ -41,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
@@ -66,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)
@@ -81,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,
@@ -94,11 +108,16 @@ module Sequel
         #            array of the allowable fields.
         # :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
+        # :reject_if :: A proc that is called with each attribute hash before it is
         #               passed to its associated object. If the proc returns a truthy
         #               value, the attribute hash is ignored.
+        # :reject_nil :: Ignore nil objects passed to nested attributes setter methods.
         # :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.
@@ -110,12 +129,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
@@ -126,10 +145,13 @@ 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
-            define_method("#{reflection[:name]}_attributes=") do |v|
-              set_nested_attributes(reflection[:name], v)
+          @nested_attributes_module.class_eval do
+            meth = :"#{reflection[:name]}_attributes="
+            assoc = reflection[:name]
+            define_method(meth) do |v|
+              set_nested_attributes(assoc, v)
             end
+            alias_method meth, meth
           end
         end
       end
@@ -141,7 +163,8 @@ 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)
+          return if obj.nil? && meta[:reject_nil]
+          meta = meta.merge(opts)
           meta[:reflection] = ref
           if ref.returns_array?
             nested_attributes_list_setter(meta, obj)
@@ -172,8 +195,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
 
@@ -185,9 +209,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)
@@ -199,7 +226,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
@@ -215,9 +242,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
@@ -233,7 +260,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
@@ -261,9 +288,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)

data/lib/sequel/plugins/optimistic_locking.rb

@@ -11,11 +11,11 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
     #
     # In order for this plugin to work, you need to make sure that the database
-    # table has a lock_version column (or other column you name via the lock_column
+    # table has a +lock_version+ column (or other column you name via the lock_column
     # class level accessor) that defaults to 0.
     #
     # This plugin relies on the instance_filters plugin.

data/lib/sequel/plugins/pg_array_associations.rb

@@ -75,12 +75,12 @@ module Sequel
     module PgArrayAssociations
       # The AssociationReflection subclass for many_to_pg_array associations.
       class ManyToPgArrayAssociationReflection < Sequel::Model::Associations::AssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:many_to_pg_array] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:many_to_pg_array] = self}
 
         def array_type
           cached_fetch(:array_type) do
             if (sch = associated_class.db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
-              t
+              t.sub(/\[\]\z/, '').freeze
             else
               :integer
             end
@@ -122,6 +122,13 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :array_type=>:array_type
+        ).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
@@ -153,7 +160,7 @@ module Sequel
 
         def filter_by_associations_add_conditions_dataset_filter(ds)
           key = qualify(associated_class.table_name, self[:key])
-          ds.select{unnest(key)}.exclude(key=>nil)
+          ds.cross_join(Sequel.function(:unnest, key).as(:_smtopgaa_, [:_smtopgaa_key_])).exclude(key=>nil).select(:_smtopgaa_key_)
         end
         
         def filter_by_associations_conditions_key
@@ -177,12 +184,12 @@ module Sequel
 
       # The AssociationReflection subclass for pg_array_to_many associations.
       class PgArrayToManyAssociationReflection < Sequel::Model::Associations::AssociationReflection
-        Sequel::Model::Associations::ASSOCIATION_TYPES[:pg_array_to_many] = self
+        Sequel.synchronize{Sequel::Model::Associations::ASSOCIATION_TYPES[:pg_array_to_many] = self}
 
         def array_type
           cached_fetch(:array_type) do
             if (sch = self[:model].db_schema) && (s = sch[self[:key]]) && (t = s[:db_type])
-              t
+              t.sub(/\[\]\z/, '').freeze
             else
               :integer
             end
@@ -229,6 +236,15 @@ module Sequel
           nil
         end
 
+        FINALIZE_SETTINGS = superclass::FINALIZE_SETTINGS.merge(
+          :array_type=>:array_type,
+          :primary_key=>:primary_key,
+          :primary_key_method=>:primary_key_method
+        ).freeze
+        def finalize_settings
+          FINALIZE_SETTINGS
+        end
+
         # Handle silent failure of add/remove methods if raise_on_save_failure is false
         # and save_after_modify is true.
         def handle_silent_modification_failure?
@@ -281,6 +297,11 @@ module Sequel
         end
       end
 
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
       module ClassMethods
         # Create a many_to_pg_array association, for the case where the associated
         # table contains the array with foreign keys pointing to the current table.
@@ -307,18 +328,22 @@ module Sequel
           opts[:key] = opts.default_key unless opts.has_key?(:key)
           key = opts[:key]
           key_column = opts[:key_column] ||= opts[:key]
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([get_column_value(pk)], opts.array_type)))
           end
           opts[:eager_loader] ||= proc do |eo|
             id_map = eo[:id_map]
+            eo = Hash[eo]
+            eo[:loader] = false
 
-            eager_load_results(opts, Hash[eo].merge!(:loader=>false)) do |assoc_record|
-              if pks ||= assoc_record.get_column_value(key)
+            eager_load_results(opts, eo) do |assoc_record|
+              if pks = assoc_record.get_column_value(key)
                 pks.each do |pkv|
-                  next unless objects = id_map[pkv]
-                  objects.each do |object| 
+                  id_map[pkv].each do |object| 
                     object.associations[name].push(assoc_record)
                   end
                 end
@@ -350,7 +375,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), 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(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -359,24 +384,32 @@ module Sequel
           save_opts = {:validate=>opts[:validate]}
           save_opts[:raise_on_failure] = opts[:raise_on_save_failure] != false
 
-          opts[:adder] ||= proc do |o|
-            if array = o.get_column_value(key)
-              array << get_column_value(pk)
-            else
-              o.set_column_value("#{key}=", Sequel.pg_array([get_column_value(pk)], opts.array_type))
+          unless opts.has_key?(:adder)
+            opts[:adder] = proc do |o|
+              if array = o.get_column_value(key)
+                array << get_column_value(pk)
+              else
+                o.set_column_value("#{key}=", Sequel.pg_array([get_column_value(pk)], opts.array_type))
+              end
+              o.save(save_opts)
             end
-            o.save(save_opts)
           end
-  
-          opts[:remover] ||= proc do |o|
-            if (array = o.get_column_value(key)) && !array.empty?
-              array.delete(get_column_value(pk))
-              o.save(save_opts)
+    
+          unless opts.has_key?(:remover)
+            opts[:remover] = proc do |o|
+              if (array = o.get_column_value(key)) && !array.empty?
+                array.delete(get_column_value(pk))
+                o.save(save_opts)
+              end
             end
           end
 
-          opts[:clearer] ||= proc do
-            opts.associated_dataset.where(Sequel.pg_array_op(key).contains([get_column_value(pk)])).update(key=>Sequel.function(:array_remove, key, get_column_value(pk)))
+          unless opts.has_key?(:clearer)
+            opts[:clearer] = proc do
+              pk_value = get_column_value(pk)
+              db_type = opts.array_type
+              opts.associated_dataset.where(Sequel.pg_array_op(key).contains(Sequel.pg_array([pk_value], db_type))).update(key=>Sequel.function(:array_remove, key, Sequel.cast(pk_value, db_type)))
+            end
           end
         end
 
@@ -387,7 +420,10 @@ module Sequel
           key = opts[:key]
           key_column = opts[:key_column] ||= key
           opts[:eager_loader_key] = nil
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(opts.predicate_key=>get_column_value(key).to_a)
           end
@@ -396,15 +432,19 @@ module Sequel
             id_map = {}
             pkm = opts.primary_key_method
 
-            rows.each do |object|
-              if associated_pks = object.get_column_value(key)
-                associated_pks.each do |apk|
-                  (id_map[apk] ||= []) << object
+            Sequel.synchronize_with(eo[:mutex]) do
+              rows.each do |object|
+                if associated_pks = object.get_column_value(key)
+                  associated_pks.each do |apk|
+                    (id_map[apk] ||= []) << object
+                  end
                 end
               end
             end
 
-            eager_load_results(opts, Hash[eo].merge!(:id_map=>id_map)) do |assoc_record|
+            eo = Hash[eo]
+            eo[:id_map] = id_map
+            eager_load_results(opts, eo) do |assoc_record|
               if objects = id_map[assoc_record.get_column_value(pkm)]
                 objects.each do |object| 
                   object.associations[name].push(assoc_record)
@@ -437,7 +477,7 @@ module Sequel
 
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), 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(eager_graph_dataset(opts, eo), conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             ds
           end
 
@@ -452,30 +492,36 @@ module Sequel
             end
           end
 
-          opts[:adder] ||= proc do |o|
-            opk = o.get_column_value(opts.primary_key) 
-            if array = get_column_value(key)
-              modified!(key)
-              array << opk
-            else
-              set_column_value("#{key}=", Sequel.pg_array([opk], opts.array_type))
+          unless opts.has_key?(:adder)
+            opts[:adder] = proc do |o|
+              opk = o.get_column_value(opts.primary_key) 
+              if array = get_column_value(key)
+                modified!(key)
+                array << opk
+              else
+                set_column_value("#{key}=", Sequel.pg_array([opk], opts.array_type))
+              end
+              save_after_modify.call(self) if save_after_modify
             end
-            save_after_modify.call(self) if save_after_modify
           end
-  
-          opts[:remover] ||= proc do |o|
-            if (array = get_column_value(key)) && !array.empty?
-              modified!(key)
-              array.delete(o.get_column_value(opts.primary_key))
-              save_after_modify.call(self) if save_after_modify
+    
+          unless opts.has_key?(:remover)
+            opts[:remover] = proc do |o|
+              if (array = get_column_value(key)) && !array.empty?
+                modified!(key)
+                array.delete(o.get_column_value(opts.primary_key))
+                save_after_modify.call(self) if save_after_modify
+              end
             end
           end
 
-          opts[:clearer] ||= proc do
-            if (array = get_column_value(key)) && !array.empty?
-              modified!(key)
-              array.clear
-              save_after_modify.call(self) if save_after_modify
+          unless opts.has_key?(:clearer)
+            opts[:clearer] = proc do
+              if (array = get_column_value(key)) && !array.empty?
+                modified!(key)
+                array.clear
+                save_after_modify.call(self) if save_after_modify
+              end
             end
           end
         end
@@ -488,17 +534,19 @@ module Sequel
         def many_to_pg_array_association_filter_expression(op, ref, obj)
           pk = ref.qualify(model.table_name, ref.primary_key)
           key = ref[:key]
+          # :nocov:
           expr = case obj
+          # :nocov:
           when Sequel::Model
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
-              Sequel.expr(pk=>assoc_pks.to_a)
+              Sequel[pk=>assoc_pks.to_a]
             end
           when Array
             if (assoc_pks = obj.map{|o| o.get_column_value(key)}.flatten.compact.uniq) && !assoc_pks.empty?
-              Sequel.expr(pk=>assoc_pks)
+              Sequel[pk=>assoc_pks]
             end
           when Sequel::Dataset
-            Sequel.expr(pk=>obj.select{Sequel.pg_array_op(ref.qualify(obj.model.table_name, ref[:key_column])).unnest})
+            obj.select(ref.qualify(obj.model.table_name, ref[:key_column]).as(:key)).from_self.where{{pk=>any(:key)}}.select(1).exists
           end
           expr = Sequel::SQL::Constants::FALSE unless expr
           expr = add_association_filter_conditions(ref, obj, expr)
@@ -508,7 +556,9 @@ module Sequel
         # Support filtering by pg_array_to_many associations using a subquery.
         def pg_array_to_many_association_filter_expression(op, ref, obj)
           key = ref.qualify(model.table_name, ref[:key_column])
+          # :nocov:
           expr = case obj
+          # :nocov:
           when Sequel::Model
             if pkv = obj.get_column_value(ref.primary_key_method)
               Sequel.pg_array_op(key).contains(Sequel.pg_array([pkv], ref.array_type))