sequel 5.106.0 → 5.109.0

data/lib/sequel/plugins/association_proxies.rb

@@ -64,7 +64,7 @@ module Sequel
         array = [].freeze
 
         if RUBY_VERSION < '2.6'
-          # :nocov:
+          # simplecov:disable
 
           # Default proc used to determine whether to send the method to the dataset.
           # If the array would respond to it, sends it to the array instead of the dataset.
@@ -75,7 +75,7 @@ module Sequel
             end
             !array_method
           end
-          # :nocov:
+          # simplecov:enable
         else
           DEFAULT_PROXY_TO_DATASET = proc{|opts| !array.respond_to?(opts[:method])}
         end
@@ -99,9 +99,9 @@ module Sequel
           end
           v.public_send(meth, *args, &block)
         end
-        # :nocov:
+        # simplecov:disable
         ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
-        # :nocov:
+        # simplecov:enable
       end
 
       module ClassMethods

data/lib/sequel/plugins/auto_restrict_eager_graph.rb

@@ -1,5 +1,7 @@
 # frozen-string-literal: true
 
+# SEQUEL6: Merge into default associations code
+
 module Sequel
   module Plugins
     # The auto_restrict_eager_graph plugin will automatically disallow the use

data/lib/sequel/plugins/caching.rb

@@ -29,6 +29,13 @@ module Sequel
     #
     # You should not use this plugin if you are using sharding and there are different
     # rows for the same primary key on different shards.
+    #
+    # Note that if you are using a composite key, and multiple columns in the composite
+    # key could potentially contain the character ",", you should override the
+    # +composite_cache_key+ class method to return an an unambiguous string identifying
+    # the specific primary key argument given. For consistency, if you would like to
+    # modify the cache key string used for scalar primary keys, you can override the
+    # +scalar_cache_key+ class method.
     # 
     # Usage:
     #
@@ -53,7 +60,7 @@ module Sequel
       end
 
       module ClassMethods
-        # If true, ignores exceptions when gettings cached records (the memcached API).
+        # If true, ignores exceptions when getting cached records (the memcached API).
         attr_reader :cache_ignore_exceptions
         
         # The cache store object for the model, which should implement the
@@ -81,8 +88,26 @@ module Sequel
 
         # Return a key string for the given primary key.
         def cache_key(pk)
-          raise(Error, 'no primary key for this record') unless pk.is_a?(Array) ? pk.all? : pk
-          "#{cache_key_prefix}:#{Array(pk).join(',')}"
+          case pk
+          when Array
+            raise(Error, 'no primary key for this record') unless pk.all?
+            "#{cache_key_prefix}:#{composite_cache_key(pk)}"
+          else
+            raise(Error, 'no primary key for this record') unless pk
+            "#{cache_key_prefix}:#{scalar_cache_key(pk)}"
+          end
+        end
+
+        # Return an appropriate cache key string for a valid scalar primary key.
+        # By default, converts the primary key to a string.
+        def scalar_cache_key(pk)
+          pk.to_s
+        end
+
+        # Return an appropriate cache key string for a valid composite primary key.
+        # By default, joins with the parts of the compsite key with ",".
+        def composite_cache_key(pk)
+          pk.join(',')
         end
         
         Plugins.inherited_instance_variables(self, :@cache_store=>nil, :@cache_ttl=>nil, :@cache_ignore_exceptions=>nil)

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -79,7 +79,7 @@ module Sequel
     # subclass instances that only have column entries for the columns in the
     # superclass table.  Calling the column method on the subclass instance for
     # a column not in the superclass table will cause a query to the database
-    # to get the value for that column.  If the subclass instance was retreived
+    # to get the value for that column.  If the subclass instance was retrieved
     # using Dataset#all, the query to the database will attempt to load the column
     # values for all subclass instances that were retrieved.  For example:
     #

data/lib/sequel/plugins/column_encryption.rb

@@ -1,8 +1,8 @@
 # frozen-string-literal: true
 
-# :nocov:
+# simplecov:disable
 raise(Sequel::Error, "Sequel column_encryption plugin requires ruby 2.3 or greater") unless RUBY_VERSION >= '2.3'
-# :nocov:
+# simplecov:enable
 
 require 'openssl'
 
@@ -22,13 +22,13 @@ begin
   cipher.key = '1'*32
   cipher.auth_data = ''
   cipher.auth_tag = auth_tag
-  # :nocov:
+  # simplecov:disable
   unless (cipher.update(cipher_text) << cipher.final) == '2'
     raise OpenSSL::Cipher::CipherError
   end
 rescue RuntimeError, OpenSSL::Cipher::CipherError
   raise LoadError, "Sequel column_encryption plugin requires a working aes-256-gcm cipher"
-  # :nocov:
+  # simplecov:enable
 end
 
 require 'securerandom'
@@ -279,7 +279,7 @@ module Sequel
     #
     # = Unsupported Features
     #
-    # The following features are delibrately not supported:
+    # The following features are deliberately not supported:
     #
     # == Compression
     #
@@ -475,12 +475,12 @@ module Sequel
           def decode64(str)
             str.unpack1("m0")
           end
-        # :nocov:
+        # simplecov:disable
         else
           def decode64(str)
             str.unpack("m0")[0]
           end
-        # :nocov:
+        # simplecov:enable
         end
 
         def urlsafe_encode64(bin)
@@ -493,7 +493,7 @@ module Sequel
           decode64(str.tr("-_", "+/"))
         end
 
-        # An array of strings, one for each configured encryption key, to find encypted values matching
+        # An array of strings, one for each configured encryption key, to find encrypted values matching
         # the given data and search format.
         def _search_prefixes(data, search_type)
           @key_map.map do |key_id, (key, _)|
@@ -610,7 +610,7 @@ module Sequel
         end
       end
 
-      # This stores four callables for handling encyption, decryption, data searching,
+      # This stores four callables for handling encryption, decryption, data searching,
       # and key searching.  One of these is created for each encrypted column.
       ColumnEncryptionMetadata = Struct.new(:encryptor, :decryptor, :data_searcher, :key_searcher) # :nodoc:
 
@@ -702,7 +702,7 @@ module Sequel
 
       module InstanceMethods
         # Reencrypt the model if needed.  Looks at all of the models encrypted columns
-        # and if any were encypted with older keys or a different format, reencrypt
+        # and if any were encrypted with older keys or a different format, reencrypt
         # with the current key and format and save the object.  Returns the object
         # if reencryption was needed, or nil if reencryption was not needed.
         def reencrypt

data/lib/sequel/plugins/concurrent_eager_loading.rb

@@ -69,8 +69,8 @@ module Sequel
     # To keep things simple, you can use +Sequel.synchronize_with+ to only
     # use this mutex if it is available.  You want to use the mutex around the
     # code that initializes the associations (usually to +nil+ or <tt>[]</tt>),
-    # and also around the code that sets the associatied objects appropriately
-    # after they have been retreived.  You do not want to use the mutex around
+    # and also around the code that sets the associated objects appropriately
+    # after they have been retrieved.  You do not want to use the mutex around
     # the code that loads the objects, since that will prevent concurrent loading.
     # So after the changes, the custom eager loader would look like this:
     #

data/lib/sequel/plugins/csv_serializer.rb

@@ -73,23 +73,12 @@ module Sequel
         end
       end
 
-      # Avoid keyword argument separation warnings on Ruby 2.7, while still
-      # being compatible with 1.9.
-      if RUBY_VERSION >= "2.0"
-        instance_eval(<<-END, __FILE__, __LINE__+1)
-          def self.csv_call(*args, opts, &block)
-            CSV.send(*args, **opts, &block)
-          end
-        END
-      else
-        # :nocov:
-        # :nodoc:
-        def self.csv_call(*args, opts, &block)
-          CSV.send(*args, opts, &block)
-        end
-        # :nodoc:
-        # :nocov:
+      # simplecov:disable
+      def self.csv_call(*args, opts, &block)
+        Sequel::Deprecation.deprecate("Sequel::Plugins::CsvSerializer.csv_call will be removed in Sequel 6.")
+        CSV.send(*args, **opts, &block)
       end
+      # simplecov:enable
 
       module ClassMethods
         # The default opts to use when serializing model objects to CSV
@@ -97,7 +86,7 @@ module Sequel
 
         # Attempt to parse an array of instances from the given CSV string
         def array_from_csv(csv, opts = OPTS)
-          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
+          CSV.parse(csv, **process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
@@ -147,7 +136,7 @@ module Sequel
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
         def from_csv(csv, opts = OPTS)
-          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
+          row = CSV.parse_line(csv, **model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -165,7 +154,7 @@ module Sequel
           opts = model.process_csv_serializer_opts(opts)
           headers = opts[:headers]
 
-          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+          CSV.generate(**model.process_csv_serializer_opts(opts)) do |csv|
             csv << headers.map{|k| public_send(k)}
           end
         end
@@ -184,7 +173,7 @@ module Sequel
           items = opts.delete(:array) || self
           headers = opts[:headers]
 
-          CsvSerializer.csv_call(:generate, opts) do |csv|
+          CSV.generate(**opts) do |csv|
             items.each do |object|
               csv << headers.map{|header| object.public_send(header)}
             end

data/lib/sequel/plugins/deprecated_associations.rb

@@ -105,9 +105,9 @@ module Sequel
                 end
                 super(*a, &b)
               end
-              # :nocov:
+              # simplecov:disable
               ruby2_keywords(name) if respond_to?(:ruby2_keywords, true)
-              # :nocov:
+              # simplecov:enable
               alias_method(name, name)
             end
           end

data/lib/sequel/plugins/eager_each.rb

@@ -77,7 +77,7 @@ module Sequel
 
         private
 
-        # Wether to use all when each is called, true when eager loading
+        # Whether to use all when each is called, true when eager loading
         # unless the flag has already been set.
         def use_eager_all?
           (opts[:eager] || opts[:eager_graph]) && !opts[:all_called]

data/lib/sequel/plugins/finder.rb

@@ -237,7 +237,7 @@ module Sequel
           end
         end
 
-        # Clear any finders when reseting the instance dataset
+        # Clear any finders when resetting the instance dataset
         def reset_instance_dataset
           Sequel.synchronize{@finders.clear} if @finders && !@finders.frozen?
           super

data/lib/sequel/plugins/forbid_lazy_load.rb

@@ -9,7 +9,7 @@ module Sequel
     # The main reason for doing this is it makes it easier to detect
     # N+1 query issues. Note that Sequel also offers a
     # tactical_eager_loading plugin which will automatically eagerly
-    # load associations for all objects retrived in the same query
+    # load associations for all objects retrieved in the same query
     # if any object would attempt to lazily load an association. That
     # approach may be simpler if you are trying to prevent N+1 issues,
     # though it does retain more objects in memory.
@@ -125,9 +125,9 @@ module Sequel
         # an association, allow lazy loading that association, since the
         # lazy association load will use a hash table lookup and not a query.
         def allow_lazy_load_for_static_cache_associations
-          # :nocov:
+          # simplecov:disable
           if defined?(::Sequel::Plugins::StaticCache::ClassMethods)
-          # :nocov:
+          # simplecov:enable
             @association_reflections.each_value do |ref|
               if ref.associated_class.is_a?(::Sequel::Plugins::StaticCache::ClassMethods)
                 ref[:forbid_lazy_load] = false

data/lib/sequel/plugins/insert_conflict.rb

@@ -19,7 +19,7 @@ module Sequel
     #
     # This example will try to insert the album, but if there is an existing
     # album with the name 'Foo', this will update the copies_sold attribute
-    # for that album.  See the PostgreSQL and SQLite adapter documention for
+    # for that album.  See the PostgreSQL and SQLite adapter documentation for
     # the options you can pass to the insert_conflict method.
     #
     # You should not attempt to use this plugin to ignore conflicts when

data/lib/sequel/plugins/insert_returning_select.rb

@@ -32,7 +32,7 @@ module Sequel
 
         private
 
-        # When reseting the instance dataset, also reset the instance_insert_dataset.
+        # When resetting the instance dataset, also reset the instance_insert_dataset.
         def reset_instance_dataset
           ret = super
           return unless ds = @instance_dataset

data/lib/sequel/plugins/instance_filters.rb

@@ -80,6 +80,14 @@ module Sequel
           instance_filters << [args, block]
         end
       
+        # Clear instance filters when saving changes even if the
+        # object wasn't modified.
+        def save_changes(opts=OPTS)
+          ret = super
+          clear_instance_filters if ret.nil?
+          ret
+        end
+
         private
         
         # If there are any instance filters, make sure not to use the

data/lib/sequel/plugins/instance_hooks.rb

@@ -93,6 +93,25 @@ module Sequel
           super
         end
         
+        # Run and clear save/update/validation hooks when saving changes even if the
+        # object wasn't modified.
+        def save_changes(opts=OPTS)
+          ret = super
+          if ret.nil? && @instance_hooks
+            run_before_instance_hooks(:before_validation)
+            run_before_instance_hooks(:after_validation)
+            run_before_instance_hooks(:before_save)
+            run_before_instance_hooks(:before_update)
+            ret = super
+            run_before_instance_hooks(:after_update)
+            run_before_instance_hooks(:after_save)
+            [:before_validation, :after_validation, :before_save, :before_update, :after_update, :after_save].each do |type|
+              @instance_hooks.delete(type)
+            end
+          end
+          ret
+        end
+
         private
         
         # Add the block as an instance level hook.  For before hooks, add it to

data/lib/sequel/plugins/json_serializer.rb

@@ -128,7 +128,7 @@ module Sequel
       end
       
       # SEQUEL6: Remove
-      # :nocov:
+      # simplecov:disable
       class Literal
         def initialize(json)
           @json = json
@@ -138,7 +138,7 @@ module Sequel
           @json
         end
       end
-      # :nocov:
+      # simplecov:enable
       Sequel::Deprecation.deprecate_constant(self, :Literal)
 
       # Convert the given object to a JSON data structure using the given arguments.
@@ -151,11 +151,11 @@ module Sequel
           else
             begin
               Sequel.parse_json(Sequel.object_to_json(obj, *args, &block))
-            # :nocov:
+            # simplecov:disable
             rescue Sequel.json_parser_error_class
               # Support for old Ruby code that only supports parsing JSON object/array
               Sequel.parse_json(Sequel.object_to_json([obj], *args, &block))[0]
-            # :nocov:
+            # simplecov:enable
             end
           end
         end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -5,7 +5,7 @@ module Sequel
     # The lazy_attributes plugin allows users to easily set that some attributes
     # should not be loaded by default when loading model objects.  If the attribute
     # is needed after the instance has been retrieved, a database query is made to
-    # retreive the value of the attribute.
+    # retrieve the value of the attribute.
     #
     # This plugin depends on the tactical_eager_loading plugin, and allows you to
     # eagerly load lazy attributes for all objects retrieved with the current object.

data/lib/sequel/plugins/many_through_many.rb

@@ -243,7 +243,7 @@ module Sequel
         #            :conditions :: Extra conditions to add to the JOIN ON clause.  Must be a hash or array of two pairs.
         #            :join_type :: The join type to use for the join, defaults to :left_outer.
         #            :only_conditions :: Conditions to use for the join instead of the ones specified by the keys.
-        # opts :: The options for the associaion.  Takes the same options as many_to_many.
+        # opts :: The options for the association.  Takes the same options as many_to_many.
         def many_through_many(name, through, opts=OPTS, &block)
           associate(:many_through_many, name, opts.merge(through.is_a?(Hash) ? through : {:through=>through}), &block)
         end

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -22,6 +22,13 @@ module Sequel
     #
     #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
+    # By default, the plugin allows using the lock column setter method to
+    # either increase or decrease the lock column 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 option:
+    #
+    #     plugin :mssql_optimistic_locking, prevent_increase: true
+    #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking
       # Load the instance_filters plugin into the model.
@@ -32,6 +39,8 @@ module Sequel
       # Set the lock column
       def self.configure(model, opts=OPTS)
         model.lock_column = opts[:lock_column] || model.lock_column || :timestamp
+        # SEQUEL6: Make prevent_increase true by default
+        model.send(:prevent_lock_column_increase!) if opts[:prevent_increase]
       end
       
       module InstanceMethods

data/lib/sequel/plugins/optimistic_locking.rb

@@ -20,6 +20,13 @@ module Sequel
     #
     #     plugin :optimistic_locking, lock_column: :version
     #
+    # By default, the plugin allows using the lock column setter method to
+    # either increase or decrease the lock column 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 option:
+    #
+    #     plugin :optimistic_locking, prevent_increase: true
+    #
     # This plugin relies on the instance_filters plugin.
     module OptimisticLocking
       # Exception class raised when trying to update or destroy a stale object.
@@ -32,6 +39,8 @@ module Sequel
       # Set the lock column
       def self.configure(model, opts=OPTS)
         model.lock_column = opts[:lock_column] || model.lock_column || :lock_version
+        # SEQUEL6: Make prevent_increase true by default
+        model.send(:prevent_lock_column_increase!) if opts[:prevent_increase]
       end
 
       module InstanceMethods
@@ -42,9 +51,10 @@ module Sequel
         def _update_columns(columns)
           lc = model.lock_column
           lcv = get_column_value(lc)
-          columns[lc] = lcv + 1
+          new_lcv = columns[lc] = lcv + 1
           super
-          set_column_value("#{lc}=", lcv + 1)
+          set_column_value("#{lc}=", nil)
+          set_column_value("#{lc}=", new_lcv)
           changed_columns.delete(lc)
           nil
         end

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_array_associations.rb

@@ -534,9 +534,9 @@ 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:
+          # simplecov:disable
           expr = case obj
-          # :nocov:
+          # simplecov:enable
           when Sequel::Model
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks.to_a]
@@ -556,9 +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:
+          # simplecov:disable
           expr = case obj
-          # :nocov:
+          # simplecov:enable
           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))

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -261,9 +261,9 @@ module Sequel
             messages = model.pg_auto_constraint_validations_messages
 
             unless override
-              # :nocov:
+              # simplecov:disable
               case e
-              # :nocov:
+              # simplecov:enable
               when Sequel::NotNullConstraintViolation
                 if column = info[:column]
                   add_pg_constraint_validation_error([m.call(column)], messages[:not_null])
@@ -297,7 +297,7 @@ module Sequel
               end
             end
           rescue
-            # If there is an error trying to conver the constraint violation
+            # If there is an error trying to convert the constraint violation
             # into a validation failure, it's best to just raise the constraint
             # violation.  This can make debugging the above block of code more
             # difficult.

data/lib/sequel/plugins/pg_eager_any_typed_array.rb

@@ -45,7 +45,7 @@ module Sequel
               key = key.column
             end
 
-            # :nocov:
+            # simplecov:disable
             # many_to_pg_array association type does not need changes, as it
             # already converts the values to a typed postgres array, it does
             # not call the code that uses :eager_loading_predicate_transform.
@@ -54,7 +54,7 @@ module Sequel
             # unless it is one of these types, but external association types
             # could potentially reach it.
             sch = case ref[:type]
-            # :nocov:
+            # simplecov:enable
             when :many_to_one, :one_to_one, :one_to_many, :pg_array_to_many
               ref.associated_class.db_schema
             when :many_to_many, :one_through_one

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/prepared_statements.rb

@@ -181,11 +181,11 @@ module Sequel
             # Disabling usage of prepared statements for insert_select on SQLite seems to be the
             # simplest way to workaround the problem.
             db.database_type != :sqlite
-          # :nocov:
+          # simplecov:disable
           when :delete, :refresh
             Sequel::Deprecation.deprecate("The :delete and :refresh prepared statement types", "There should be no need to check if these types are supported")
             false
-          # :nocov:
+          # simplecov:enable
           else
             raise Error, "unsupported type used: #{type.inspect}"
           end