sequel 5.108.0 → 5.109.0

data/lib/sequel/plugins/optimistic_locking_base.rb

@@ -12,6 +12,20 @@ module Sequel
       module ClassMethods
         # The column holding the version of the lock
         attr_accessor :lock_column
+
+        private
+
+        # Prevent increasing the value of the lock column. If the lock column
+        # has an existing value, do not allow setting a value that is higher
+        # than it.
+        def prevent_lock_column_increase!
+          lc = lock_column
+          define_method(:"#{lc}=") do |v|
+            unless v && (lv = send(lc)) && v > lv
+              super(v)
+            end
+          end
+        end
         
         Plugins.inherited_instance_variables(self, :@lock_column=>nil)
       end

data/lib/sequel/plugins/pg_xmin_optimistic_locking.rb

@@ -21,6 +21,13 @@ module Sequel
     # optimistic locking.  The disadvantage is that testing can be
     # more difficult if you are modifying the underlying row between
     # when a model is retrieved and when it is saved.
+
+    # By default, the plugin allows using the +xmin=+ setter method to
+    # either increase or decrease the lock value. To prevent increases,
+    # which could potentially be used to skip an update when it update should
+    # be made, you can use the +:prevent_increase+ plugin argument:
+    #
+    #     plugin :pg_xmin_optimistic_locking, prevent_increase: true
     #
     # This plugin may not work with the class_table_inheritance plugin.
     #
@@ -29,7 +36,7 @@ module Sequel
       WILDCARD = LiteralString.new('*').freeze
       
       # Define the xmin column accessor
-      def self.apply(model)
+      def self.apply(model, prevent_increase: false)
         model.instance_exec do
           plugin(:optimistic_locking_base)
           @lock_column = :xmin
@@ -39,9 +46,11 @@ module Sequel
 
       # Update the dataset to append the xmin column if it is usable
       # and there is a dataset for the model.
-      def self.configure(model)
+      def self.configure(model, prevent_increase: false)
         model.instance_exec do
           set_dataset(@dataset) if @dataset
+          # SEQUEL6: Make prevent_increase true by default
+          prevent_lock_column_increase! if prevent_increase
         end
       end
 

data/lib/sequel/plugins/select_on_skipped_update.rb

@@ -0,0 +1,63 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # This plugin changes the default model behavior so that for existing
+    # objects, if Model#save_changes skips the save as the object is not
+    # modified, or if the UPDATE query is skipped as there were no columns
+    # to update, Sequel will issue a SELECT query to make sure the object
+    # still exists. This is only done if require_modification is set for
+    # the object, so that these cases will raise the same error that
+    # Sequel would raise if the UPDATE require was run but did not modify
+    # a row.
+    # 
+    #   class Item < Sequel::Model
+    #     plugin :select_on_skipped_update
+    #   end
+    #
+    #   item = Item[1]
+    #
+    #   # Delete the item from the database
+    #   Item.where(id: 1).delete
+    #
+    #   # By default, this would return nil, but with the plugin,
+    #   # this raises Sequel::NoExistingRow.
+    #   item.save_changes
+    #
+    #   # By default, this would return the object without issuing the
+    #   # UPDATE query (as the columns to update is empty. With the plugin,
+    #   # this raises Sequel::NoExistingRow.
+    #   item.save(columns: [])
+    module SelectOnSkippedUpdate
+      COUNT = Sequel.function(:count).*.as(:count)
+      private_constant :COUNT
+
+      module InstanceMethods
+        # If an UPDATE statement was skipped as the object wasn't modified, run a SELECT query.
+        def save_changes(opts=OPTS)
+          ret = super
+          run_select_on_skipped_update if ret.nil? && require_modification
+          ret
+        end
+        
+        private
+
+        # If an UPDATE statement was skipped as there were no columns to update, run a SELECT query.
+        def _update_columns(columns)
+          ret = super
+          run_select_on_skipped_update if ret.nil? && columns.empty? && require_modification
+          ret
+        end
+
+        # Run a SELECT query on the dataset to determine whether the object still exists in the database.
+        # This will result in an exception if a single row is not modified.
+        def run_select_on_skipped_update
+          ds = _update_dataset
+          unless ds.select(COUNT).single_value! == 1
+            raise(NoMatchingRow, "Attempt to select object did not result in a single row modification")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -12,6 +12,11 @@ module Sequel
     # argument to the plugin) holds the class name as a string.  However,
     # you can override this by using the <tt>:model_map</tt> option and/or
     # the <tt>:key_map</tt> option.
+    #
+    # The +sti_key+ column can be set via mass assignment, just like any
+    # non-primary key column. Make sure to follow the recommendations in the
+    # {mass assignment guide}[rdoc-ref:doc/mass_assignment.rdoc]
+    # to ensure this column is not set with untrusted data.
     #   
     # You should only load this plugin in the parent class, not in the subclasses.
     #   
@@ -84,6 +89,7 @@ module Sequel
           @sti_key_array = nil
           @sti_key = key 
           @sti_dataset = dataset
+          @sti_root_class = self
           @sti_model_map = opts[:model_map] || lambda{|v| v if v && v != ''}
           @sti_key_map = if km = opts[:key_map]
             if km.is_a?(Hash)
@@ -150,7 +156,7 @@ module Sequel
         # This defaults to a lookup in the key map.
         attr_reader :sti_key_chooser
 
-        Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil)
+        Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil, :@sti_root_class=>nil)
 
         # Freeze STI information when freezing model class.  Note that
         # because of how STI works, you should not freeze an STI subclass
@@ -221,11 +227,23 @@ module Sequel
         # Return a class object.  If a class is given, return it directly.
         # Treat strings and symbols as class names.  If nil is given or
         # an invalid class name string or symbol is used, return self.
+        # If the class is valid but is not a subclass of the class that
+        # loaded the single_table_inheritance plugin, use the class that
+        # loaded the plugin.
         # Raise an error for other types.
         def sti_class(v)
           case v
           when String, Symbol
-            constantize(v) rescue self
+            begin
+              klass = constantize(v)
+              if Class === klass && @sti_root_class >= klass
+                klass
+              else
+                @sti_root_class
+              end
+            rescue
+              self
+            end
           when nil
             self
           when Class

data/lib/sequel/plugins/subset_conditions.rb

@@ -105,22 +105,11 @@ module Sequel
 
         private
 
-        if RUBY_VERSION >= '2'
-          # Backbone of #where_any and #where_all
-          def _where_any_all(meth, name, args)
-            ds = model.dataset
-            # #bind used here because the dataset module may not yet be included in the model's dataset
-            where(name, Sequel.send(meth, *args.map{|a| self.instance_method(:"#{a}_conditions").bind(ds).call}))
-          end
-        else
-          # Cannot bind module method to arbitrary objects in Ruby 1.9.
-          # simplecov:disable
-          def _where_any_all(meth, name, args)
-            ds = model.dataset.clone
-            ds.extend(self)
-            where(name, Sequel.send(meth, *args.map{|a| ds.send(:"#{a}_conditions")}))
-          end
-          # simplecov:enable
+        # Backbone of #where_any and #where_all
+        def _where_any_all(meth, name, args)
+          ds = model.dataset
+          # #bind used here because the dataset module may not yet be included in the model's dataset
+          where(name, Sequel.send(meth, *args.map{|a| self.instance_method(:"#{a}_conditions").bind(ds).call}))
         end
       end
     end

data/lib/sequel/plugins/throw_failures.rb

@@ -64,7 +64,7 @@ module Sequel
           end
         end
 
-        if RUBY_VERSION >= '2.2' && (!defined?(JRUBY_VERSION) || JRUBY_VERSION > '9.1')
+        if RUBY_VERSION >= '2.2' && (!defined?(JRUBY_VERSION) || JRUBY_VERSION.to_r > Rational('9.1'))
           # Throw HookFailed with the generated error.  If the throw is not
           # caught, just return the originally generated error.
           def hook_failed_error(msg)

data/lib/sequel/plugins/validate_associated.rb

@@ -43,6 +43,12 @@ module Sequel
       module InstanceMethods
         private
 
+        # Whether the associated object is valid. By default, the same as calling
+        # +valid?+ on the object, but exists so it can be overridden.
+        def associated_object_valid?(reflection, obj)
+          obj.valid?
+        end
+
         # Delay validating the associated object until validating the current object.
         def delay_validate_associated_object(reflection, obj)
           after_validation_hook{validate_associated_object(reflection, obj)}
@@ -62,7 +68,7 @@ module Sequel
             end
           end
 
-          unless obj.valid?
+          unless associated_object_valid?(reflection, obj)
             if ignore_key_errors
               # Ignore errors on the key column in the associated object. This column
               # will be set when saving to a presumably valid value using a column

data/lib/sequel/plugins/validate_associated_context.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The validate_associated_context plugin extends the validate_associated
+    # plugin to work with the validation_contexts plugin. It ensures associated
+    # objects are validated using the validation context of the current object.
+    #
+    # This plugin loads the validate_associated and validation_contexts plugins.
+    # The associated model must also use the validation_contexts plugin in order
+    # to access the validation context.
+    #
+    #   class Album < Sequel::Model
+    #     plugin :validate_associated_context
+    #     many_to_one :artist
+    #
+    #     def validate
+    #       super
+    #       validate_associated_object(model.association_reflection(:artist), artist) if artist
+    #     end
+    #   end
+    #
+    #   class Artist < Sequel::Model
+    #     plugin :validation_contexts
+    #     def validate
+    #       super
+    #       errors.add(:name, 'not present') if name.nil? && validation_context == :publish
+    #     end
+    #   end
+    #
+    #   album = Album.new(artist: Artist.new)
+    #   album.valid?                               # => true
+    #   album.valid?(validation_context: :publish) # => false
+    module ValidateAssociatedContext
+      # Depend on the validate_associated and validation_contexts plugins.
+      def self.apply(model)
+        model.plugin :validate_associated
+        model.plugin :validation_contexts
+      end
+
+      module InstanceMethods
+        private
+
+        # Whether the associated object is valid, using the validation context
+        # of the current object.
+        def associated_object_valid?(reflection, obj)
+          obj.valid?(:validation_context=>validation_context)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/sql.rb

@@ -1060,123 +1060,127 @@ module Sequel
     # in a boolean value in SQL.
     class BooleanExpression < ComplexExpression
       include BooleanMethods
-      
-      # Take pairs of values (e.g. a hash or array of two element arrays)
-      # and converts it to a +BooleanExpression+.  The operator and args
-      # used depends on the case of the right (2nd) argument:
-      #
-      # 0..10 :: left >= 0 AND left <= 10
-      # [1,2] :: left IN (1,2)
-      # nil :: left IS NULL
-      # true :: left IS TRUE 
-      # false :: left IS FALSE 
-      # /as/ :: left ~ 'as'
-      # :blah :: left = blah
-      # 'blah' :: left = 'blah'
-      #
-      # If multiple arguments are given, they are joined with the op given (AND
-      # by default, OR possible).  If negate is set to true,
-      # all subexpressions are inverted before used.  Therefore, the following
-      # expressions are equivalent:
-      #
-      #   ~from_value_pairs(hash)
-      #   from_value_pairs(hash, :OR, true)
-      def self.from_value_pairs(pairs, op=:AND, negate=false)
-        pairs = pairs.map{|l,r| from_value_pair(l, r)}
-        pairs.map!{|ce| invert(ce)} if negate
-        pairs.length == 1 ? pairs[0] : new(op, *pairs)
-      end
-
-      # Return a BooleanExpression based on the right side of the pair.
-      def self.from_value_pair(l, r)
-        case r
-        when Range
-          unless r.begin.nil?
-            begin_expr = new(:>=, l, r.begin)
-          end
-          unless r.end.nil?
-            end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
-          end
-          if begin_expr
-            if end_expr
-              new(:AND, begin_expr, end_expr)
+
+      module ClassMethods
+        # Take pairs of values (e.g. a hash or array of two element arrays)
+        # and converts it to a +BooleanExpression+.  The operator and args
+        # used depends on the case of the right (2nd) argument:
+        #
+        # 0..10 :: left >= 0 AND left <= 10
+        # [1,2] :: left IN (1,2)
+        # nil :: left IS NULL
+        # true :: left IS TRUE 
+        # false :: left IS FALSE 
+        # /as/ :: left ~ 'as'
+        # :blah :: left = blah
+        # 'blah' :: left = 'blah'
+        #
+        # If multiple arguments are given, they are joined with the op given (AND
+        # by default, OR possible).  If negate is set to true,
+        # all subexpressions are inverted before used.  Therefore, the following
+        # expressions are equivalent:
+        #
+        #   ~from_value_pairs(hash)
+        #   from_value_pairs(hash, :OR, true)
+        def from_value_pairs(pairs, op=:AND, negate=false)
+          pairs = pairs.map{|l,r| from_value_pair(l, r)}
+          pairs.map!{|ce| invert(ce)} if negate
+          pairs.length == 1 ? pairs[0] : new(op, *pairs)
+        end
+
+        # Return a BooleanExpression based on the right side of the pair.
+        def from_value_pair(l, r)
+          case r
+          when Range
+            unless r.begin.nil?
+              begin_expr = new(:>=, l, r.begin)
+            end
+            unless r.end.nil?
+              end_expr = new(r.exclude_end? ? :< : :<=, l, r.end)
+            end
+            if begin_expr
+              if end_expr
+                new(:AND, begin_expr, end_expr)
+              else
+                begin_expr
+              end
+            elsif end_expr
+              end_expr
             else
-              begin_expr
+              new(:'=', 1, 1)
             end
-          elsif end_expr
-            end_expr
-          else
-            new(:'=', 1, 1)
-          end
-        when ::Array, ::Set
-          r = r.dup.freeze unless r.frozen?
-          new(:IN, l, r)
-        when ::String
-          r = r.dup.freeze unless r.frozen?
-          new(:'=', l, r)
-        when ::Sequel::Dataset
-          new(:IN, l, r)
-        when NegativeBooleanConstant
-          new(:"IS NOT", l, r.constant)
-        when BooleanConstant
-          new(:IS, l, r.constant)
-        when NilClass, TrueClass, FalseClass
-          new(:IS, l, r)
-        when Regexp
-          StringExpression.like(l, r)
-        when DelayedEvaluation
-          Sequel.delay{|ds| from_value_pair(l, r.call(ds))}
-        when Dataset::PlaceholderLiteralizer::Argument
-          prev_transform = r.instance_variable_get(:@transformer)
-          r.transform do |v|
-            if prev_transform
-              v = prev_transform.call(v)
+          when ::Array, ::Set
+            r = r.dup.freeze unless r.frozen?
+            new(:IN, l, r)
+          when ::String
+            r = r.dup.freeze unless r.frozen?
+            new(:'=', l, r)
+          when ::Sequel::Dataset
+            new(:IN, l, r)
+          when NegativeBooleanConstant
+            new(:"IS NOT", l, r.constant)
+          when BooleanConstant
+            new(:IS, l, r.constant)
+          when NilClass, TrueClass, FalseClass
+            new(:IS, l, r)
+          when Regexp
+            StringExpression.like(l, r)
+          when DelayedEvaluation
+            Sequel.delay{|ds| from_value_pair(l, r.call(ds))}
+          when Dataset::PlaceholderLiteralizer::Argument
+            prev_transform = r.instance_variable_get(:@transformer)
+            r.transform do |v|
+              if prev_transform
+                v = prev_transform.call(v)
+              end
+              from_value_pair(l, v)
             end
-            from_value_pair(l, v)
+          else
+            new(:'=', l, r)
           end
-        else
-          new(:'=', l, r)
         end
-      end
-      private_class_method :from_value_pair
-      
-      # Invert the expression, if possible.  If the expression cannot
-      # be inverted, raise an error.  An inverted expression should match everything that the
-      # uninverted expression did not match, and vice-versa, except for possible issues with
-      # SQL NULL (i.e. 1 == NULL is NULL and 1 != NULL is also NULL).
-      #
-      #   BooleanExpression.invert(:a) # NOT "a"
-      def self.invert(ce)
-        case ce
-        when BooleanExpression
-          case op = ce.op
-          when :AND, :OR
-            BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
-          when :IN, :"NOT IN"
-            BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
-          else
-            if ce.args.length == 2
-              case ce.args[1]
-              when Function, LiteralString, PlaceholderLiteralString
-                # Special behavior to not push down inversion in this case because doing so
-                # can result in incorrect behavior for ANY/SOME/ALL operators.
-                BooleanExpression.new(:NOT, ce)
+        private :from_value_pair
+        
+        # Invert the expression, if possible.  If the expression cannot
+        # be inverted, raise an error.  An inverted expression should match everything that the
+        # uninverted expression did not match, and vice-versa, except for possible issues with
+        # SQL NULL (i.e. 1 == NULL is NULL and 1 != NULL is also NULL).
+        #
+        #   BooleanExpression.invert(:a) # NOT "a"
+        def invert(ce)
+          case ce
+          when BooleanExpression
+            case op = ce.op
+            when :AND, :OR
+              BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
+            when :IN, :"NOT IN"
+              BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.dup)
+            else
+              if ce.args.length == 2
+                case ce.args[1]
+                when Function, LiteralString, PlaceholderLiteralString
+                  # Special behavior to not push down inversion in this case because doing so
+                  # can result in incorrect behavior for ANY/SOME/ALL operators.
+                  BooleanExpression.new(:NOT, ce)
+                else
+                  BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.dup)
+                end
               else
-                BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
+                BooleanExpression.new(ComplexExpression::OPERATOR_INVERSIONS[op], *ce.args.dup)
               end
-            else
-              BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
             end
+          when StringExpression, NumericExpression
+            raise(Sequel::Error, "cannot invert #{ce.inspect}")
+          when Constant
+            ComplexExpression::CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
+          else
+            BooleanExpression.new(:NOT, ce)
           end
-        when StringExpression, NumericExpression
-          raise(Sequel::Error, "cannot invert #{ce.inspect}")
-        when Constant
-          CONSTANT_INVERSIONS[ce] || raise(Sequel::Error, "cannot invert #{ce.inspect}")
-        else
-          BooleanExpression.new(:NOT, ce)
         end
       end
 
+      extend ClassMethods
+
       # Always use an AND operator for & on BooleanExpressions
       def &(ce)
         BooleanExpression.new(:AND, self, ce)

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 108
+  MINOR = 109
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.108.0
+  version: 5.109.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -386,6 +386,7 @@ files:
 - lib/sequel/plugins/primary_key_lookup_check_values.rb
 - lib/sequel/plugins/rcte_tree.rb
 - lib/sequel/plugins/require_valid_schema.rb
+- lib/sequel/plugins/select_on_skipped_update.rb
 - lib/sequel/plugins/serialization.rb
 - lib/sequel/plugins/serialization_modification_detection.rb
 - lib/sequel/plugins/sharding.rb
@@ -416,6 +417,7 @@ files:
 - lib/sequel/plugins/update_refresh.rb
 - lib/sequel/plugins/uuid.rb
 - lib/sequel/plugins/validate_associated.rb
+- lib/sequel/plugins/validate_associated_context.rb
 - lib/sequel/plugins/validation_class_methods.rb
 - lib/sequel/plugins/validation_contexts.rb
 - lib/sequel/plugins/validation_helpers.rb
@@ -448,14 +450,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []