sequel 5.67.0 → 5.74.0

data/lib/sequel/plugins/optimistic_locking.rb

@@ -12,64 +12,31 @@ module Sequel
     #   p1 = Person[1]
     #   p2 = Person[1]
     #   p1.update(name: 'Jim') # works
-    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # In order for this plugin to work, you need to make sure that the database
-    # table has a +lock_version+ column (or other column you name via the lock_column
-    # class level accessor) that defaults to 0.
+    # table has a +lock_version+ column that defaults to 0. To change the column
+    # used, provide a +:lock_column+ option when loading the plugin:
+    #
+    #     plugin :optimistic_locking, lock_column: :version
     #
     # This plugin relies on the instance_filters plugin.
     module OptimisticLocking
       # Exception class raised when trying to update or destroy a stale object.
       Error = Sequel::NoExistingObject
       
-      # Load the instance_filters plugin into the model.
       def self.apply(model, opts=OPTS)
-        model.plugin :instance_filters
+        model.plugin(:optimistic_locking_base)
       end
 
-      # Set the lock_column to the :lock_column option, or :lock_version if
-      # that option is not given.
+      # Set the lock column
       def self.configure(model, opts=OPTS)
-        model.lock_column = opts[:lock_column] || :lock_version
+        model.lock_column = opts[:lock_column] || model.lock_column || :lock_version
       end
-      
-      module ClassMethods
-        # The column holding the version of the lock
-        attr_accessor :lock_column
-        
-        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
-      end
-    
+
       module InstanceMethods
-        # Add the lock column instance filter to the object before destroying it.
-        def before_destroy
-          lock_column_instance_filter
-          super
-        end
-        
-        # Add the lock column instance filter to the object before updating it.
-        def before_update
-          lock_column_instance_filter
-          super
-        end
-        
         private
         
-        # Add the lock column instance filter to the object.
-        def lock_column_instance_filter
-          lc = model.lock_column
-          instance_filter(lc=>get_column_value(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.
         def _update_columns(columns)

data/lib/sequel/plugins/optimistic_locking_base.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # Base for other optimistic locking plugins
+    module OptimisticLockingBase
+      # Load the instance_filters plugin into the model.
+      def self.apply(model)
+        model.plugin :instance_filters
+      end
+
+      module ClassMethods
+        # The column holding the version of the lock
+        attr_accessor :lock_column
+        
+        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
+      end
+    
+      module InstanceMethods
+        # Add the lock column instance filter to the object before destroying it.
+        def before_destroy
+          lock_column_instance_filter
+          super
+        end
+        
+        # Add the lock column instance filter to the object before updating it.
+        def before_update
+          lock_column_instance_filter
+          super
+        end
+        
+        private
+        
+        # Add the lock column instance filter to the object.
+        def lock_column_instance_filter
+          instance_filter(model.lock_column=>lock_column_instance_filter_value)
+        end
+
+        # Use the current value of the lock column
+        def lock_column_instance_filter_value
+          public_send(model.lock_column)
+        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
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/paged_operations.rb

@@ -0,0 +1,181 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The paged_operations plugin adds +paged_update+ and
+    # +paged_delete+ dataset methods.  These behave similarly to
+    # the default +update+ and +delete+ dataset methods, except
+    # that the update or deletion is done in potentially multiple
+    # queries (by default, affecting 1000 rows per query).
+    # For a large table, this prevents the change from
+    # locking the table for a long period of time.
+    #
+    # Because the point of this is to prevent locking tables for
+    # long periods of time, the separate queries are not contained
+    # in a transaction, which means if a later query fails,
+    # earlier queries will still be committed.  You could prevent
+    # this by using a transaction manually, but that defeats the
+    # purpose of using these methods.
+    #
+    # Examples:
+    #
+    #   Album.where{name <= 'M'}.paged_update(updated_at: Sequel::CURRENT_TIMESTAMP)
+    #   # SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND ("id" < 1002))
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 1002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND ("id" < 2002) AND (id >= 1002))
+    #   # ...
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 10002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # UPDATE albums SET updated_at = CURRENT_TIMESTAMP WHERE ((name <= 'M') AND (id >= 10002))
+    #
+    #   Album.where{name > 'M'}.paged_delete
+    #   # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # DELETE FROM albums WHERE ((name > 'M') AND (id < 1002))
+    #   # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # DELETE FROM albums WHERE ((name > 'M') AND (id < 2002))
+    #   # ...
+    #   # SELECT id FROM albums WHERE (name > 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # DELETE FROM albums WHERE (name > 'M')
+    #
+    # The plugin also adds a +paged_datasets+ method that will yield
+    # separate datasets limited in size that in total handle all
+    # rows in the receiver:
+    #
+    #   Album.where{name > 'M'}.paged_datasets{|ds| puts ds.sql}
+    #   # Runs: SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 1000
+    #   # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND ("id" < 1002))
+    #   # Runs: SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 1002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND ("id" < 2002) AND (id >= 1002))
+    #   # ...
+    #   # Runs: SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 10002)) ORDER BY id LIMIT 1 OFFSET 1000
+    #   # Prints: SELECT * FROM albums WHERE ((name <= 'M') AND (id >= 10002))
+    #
+    # To set the number of rows per page, pass a :rows_per_page option:
+    #
+    #   Album.where{name <= 'M'}.paged_update({x: Sequel[:x] + 1}, rows_per_page: 4)
+    #   # SELECT id FROM albums WHERE (name <= 'M') ORDER BY id LIMIT 1 OFFSET 4
+    #   # UPDATE albums SET x = x + 1 WHERE ((name <= 'M') AND ("id" < 5))
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 5)) ORDER BY id LIMIT 1 OFFSET 4
+    #   # UPDATE albums SET x = x + 1 WHERE ((name <= 'M') AND ("id" < 9) AND (id >= 5))
+    #   # ...
+    #   # SELECT id FROM albums WHERE ((name <= 'M') AND (id >= 12345)) ORDER BY id LIMIT 1 OFFSET 4
+    #   # UPDATE albums SET x = x + 1 WHERE ((name <= 'M') AND (id >= 12345))
+    # 
+    # You should avoid using +paged_update+ or +paged_datasets+
+    # with updates that modify the primary key, as such usage is
+    # not supported by this plugin.
+    #
+    # This plugin only supports models with scalar primary keys.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support paged update/delete/datasets
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :paged_operations
+    #
+    #   # Make the Album class support paged update/delete/datasets
+    #   Album.plugin :paged_operations
+    module PagedOperations
+      module ClassMethods
+        Plugins.def_dataset_methods(self, [:paged_datasets, :paged_delete, :paged_update])
+      end
+
+      module DatasetMethods
+        # Yield datasets for subsets of the receiver that are limited
+        # to no more than 1000 rows (you can configure the number of
+        # rows using +:rows_per_page+).
+        #
+        # Options:
+        # :rows_per_page :: The maximum number of rows in each yielded dataset
+        #                   (unless concurrent modifications are made to the table).
+        def paged_datasets(opts=OPTS)
+          unless defined?(yield)
+            return enum_for(:paged_datasets, opts)
+          end
+
+          pk = _paged_operations_pk(:paged_update)
+          base_offset_ds = offset_ds = _paged_operations_offset_ds(opts)
+          first = nil
+
+          while last = offset_ds.get(pk)
+            ds = where(pk < last)
+            ds = ds.where(pk >= first) if first
+            yield ds
+            first = last
+            offset_ds = base_offset_ds.where(pk >= first)
+          end
+
+          ds = self
+          ds = ds.where(pk >= first) if first
+          yield ds
+          nil
+        end
+
+        # Delete all rows of the dataset using using multiple queries so that
+        # no more than 1000 rows are deleted at a time (you can configure the
+        # number of rows using +:rows_per_page+).
+        #
+        # Options:
+        # :rows_per_page :: The maximum number of rows affected by each DELETE query
+        #                   (unless concurrent modifications are made to the table).
+        def paged_delete(opts=OPTS)
+          if (db.database_type == :oracle && !supports_fetch_next_rows?) || (db.database_type == :mssql && !is_2012_or_later?)
+            raise Error, "paged_delete is not supported on MSSQL/Oracle when using emulated offsets"
+          end
+          pk = _paged_operations_pk(:paged_delete)
+          rows_deleted = 0
+          offset_ds = _paged_operations_offset_ds(opts)
+          while last = offset_ds.get(pk)
+            rows_deleted += where(pk < last).delete
+          end
+          rows_deleted + delete
+        end
+
+        # Update all rows of the dataset using using multiple queries so that
+        # no more than 1000 rows are updated at a time (you can configure the
+        # number of rows using +:rows_per_page+). All arguments are
+        # passed to Dataset#update.
+        #
+        # Options:
+        # :rows_per_page :: The maximum number of rows affected by each UPDATE query
+        #                   (unless concurrent modifications are made to the table).
+        def paged_update(values, opts=OPTS)
+          rows_updated = 0
+          paged_datasets(opts) do |ds|
+            rows_updated += ds.update(values)
+          end
+          rows_updated
+        end
+
+        private
+
+        # Run some basic checks common to paged_{datasets,delete,update}
+        # and return the primary key to operate on as a Sequel::Identifier.
+        def _paged_operations_pk(meth)
+          raise Error, "cannot use #{meth} if dataset has a limit or offset" if @opts[:limit] || @opts[:offset]
+          if db.database_type == :db2 && db.offset_strategy == :emulate
+            raise Error, "the paged_operations plugin is not supported on DB2 when using emulated offsets, set the :offset_strategy Database option to 'limit_offset' or 'offset_fetch'"
+          end
+
+          case pk = model.primary_key
+          when Symbol
+            Sequel.identifier(pk)
+          when Array
+            raise Error, "cannot use #{meth} on a model with a composite primary key"
+          else
+            raise Error, "cannot use #{meth} on a model without a primary key"
+          end
+        end
+
+        # The dataset that will be used by paged_{datasets,delete,update}
+        # to get the upper limit for the next query.
+        def _paged_operations_offset_ds(opts)
+          if rows_per_page = opts[:rows_per_page]
+            raise Error, ":rows_per_page option must be at least 1" unless rows_per_page >= 1
+          end
+          _force_primary_key_order.offset(rows_per_page || 1000)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -28,7 +28,9 @@ module Sequel
     #
     # This plugin only works on the postgres adapter when using the pg 0.16+ driver,
     # PostgreSQL 9.3+ server, and PostgreSQL 9.3+ client library (libpq). In other cases
-    # it will be a no-op.
+    # it will be a no-op. Additionally, the plugin only handles models that select
+    # from tables.  It does not handle models that select from subqueries, such as
+    # subclasses of models using the class_table_inheritance plugin.
     #
     # Example:
     #
@@ -131,7 +133,11 @@ module Sequel
         # Dump the in-memory cached metadata to the cache file.
         def dump_pg_auto_constraint_validations_cache
           raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
-          File.open(file, 'wb'){|f| f.write(Marshal.dump(@pg_auto_constraint_validations_cache))}
+          pg_auto_constraint_validations_cache = {}
+          @pg_auto_constraint_validations_cache.sort.each do |k, v|
+            pg_auto_constraint_validations_cache[k] = v
+          end
+          File.open(file, 'wb'){|f| f.write(Marshal.dump(pg_auto_constraint_validations_cache))}
           nil
         end
 

data/lib/sequel/plugins/pg_xmin_optimistic_locking.rb

@@ -0,0 +1,109 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # This plugin implements optimistic locking mechanism on PostgreSQL based
+    # on the xmin of the row. The xmin system column is automatically set to
+    # the current transaction id whenever the row is inserted or updated:
+    # 
+    #   class Person < Sequel::Model
+    #     plugin :pg_xmin_optimistic_locking
+    #   end
+    #   p1 = Person[1]
+    #   p2 = Person[1]
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
+    #
+    # The advantage of pg_xmin_optimistic_locking plugin compared to the
+    # regular optimistic_locking plugin as that it does not require any
+    # additional columns setup on the model.  This allows it to be loaded
+    # in the base model and have all subclasses automatically use
+    # 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.
+    #
+    # This plugin may not work with the class_table_inheritance plugin.
+    #
+    # This plugin relies on the instance_filters plugin.
+    module PgXminOptimisticLocking
+      WILDCARD = LiteralString.new('*').freeze
+      
+      # Define the xmin column accessor
+      def self.apply(model)
+        model.instance_exec do
+          plugin(:optimistic_locking_base)
+          @lock_column = :xmin
+          def_column_accessor(:xmin)
+        end
+      end
+
+      # Update the dataset to append the xmin column if it is usable
+      # and there is a dataset for the model.
+      def self.configure(model)
+        model.instance_exec do
+          set_dataset(@dataset) if @dataset
+        end
+      end
+
+      module ClassMethods
+        private
+
+        # Ensure the dataset selects the xmin column if doing so 
+        def convert_input_dataset(ds)
+          append_xmin_column_if_usable(super)
+        end
+
+        # If the xmin column is not already selected, and selecting it does not
+        # raise an error, append it to the selections.
+        def append_xmin_column_if_usable(ds)
+          select = ds.opts[:select]
+
+          unless select && select.include?(:xmin)
+            xmin_ds = ds.select_append(:xmin)
+            begin
+              columns = xmin_ds.columns!
+            rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
+              raise
+            rescue Sequel::DatabaseError
+              # ignore, could be view, subquery, table returning function, etc.
+            else
+              ds = xmin_ds if columns.include?(:xmin)
+            end
+          end
+
+          ds
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Only set the lock column instance filter if there is an xmin value. 
+        def lock_column_instance_filter
+          super if @values[:xmin]
+        end
+
+        # Include xmin value when inserting initial row
+        def _insert_dataset
+          super.returning(WILDCARD, :xmin)
+        end
+        
+        # Remove the xmin from the columns to update.
+        # PostgreSQL automatically updates the xmin value, and it cannot be assigned.
+        def _save_update_all_columns_hash
+          v = super
+          v.delete(:xmin)
+          v
+        end
+
+        # Add an RETURNING clause to fetch the updated xmin when updating the row.
+        def _update_without_checking(columns)
+          ds = _update_dataset
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.returning(:xmin).update_sql(columns))).all
+          values[:xmin] = rows.first[:xmin] unless rows.empty?
+          rows.length
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/static_cache.rb

@@ -64,6 +64,9 @@ module Sequel
       def self.configure(model, opts=OPTS)
         model.instance_exec do
           @static_cache_frozen = opts.fetch(:frozen, true)
+          if @static_cache_frozen && defined?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods) && is_a?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods)
+            extend ForbidLazyLoadClassMethods
+          end
           load_cache
         end
       end
@@ -246,6 +249,41 @@ module Sequel
         end
       end
 
+      module ForbidLazyLoadClassMethods
+        # Do not forbid lazy loading for single object retrieval.
+        def cache_get_pk(pk)
+          primary_key_lookup(pk)
+        end
+
+        # Use static cache to return first arguments.
+        def first(*args)
+          if !defined?(yield) && args.empty?
+            if o = @all.first
+              _static_cache_frozen_copy(o)
+            end
+          else
+            super
+          end
+        end
+
+        private
+
+        # Return a frozen copy of the object that does not have lazy loading
+        # forbidden.
+        def _static_cache_frozen_copy(o)
+          o = call(Hash[o.values])
+          o.errors.freeze
+          o.freeze
+        end
+
+        # Do not forbid lazy loading for single object retrieval.
+        def primary_key_lookup(pk)
+          if o = cache[pk]
+            _static_cache_frozen_copy(o)
+          end
+        end
+      end
+
       module InstanceMethods
         # Disallowing destroying the object unless the frozen: false option was used.
         def before_destroy

data/lib/sequel/plugins/static_cache_cache.rb

@@ -26,7 +26,11 @@ module Sequel
       module ClassMethods
         # Dump the in-memory cached rows to the cache file.
         def dump_static_cache_cache
-          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(@static_cache_cache))}
+          static_cache_cache = {}
+          @static_cache_cache.sort.each do |k, v|
+            static_cache_cache[k] = v
+          end
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(static_cache_cache))}
           nil
         end
 

data/lib/sequel/plugins/validation_helpers.rb

@@ -75,6 +75,10 @@ module Sequel
     #       "#{Array(attribute).join(I18n.t('errors.joiner'))} #{error_msg}"
     #     end
     #   end
+    #
+    # It is recommended that users of this plugin that use validates_schema_types also use
+    # the validation_helpers_generic_type_messages plugin for more useful type validation
+    # failure messages.
     module ValidationHelpers
       DEFAULT_OPTIONS = {
         :exact_length=>{:message=>lambda{|exact| "is not #{exact} characters"}},
@@ -211,7 +215,7 @@ module Sequel
           klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
           validatable_attributes_for_type(:type, atts, opts) do |a,v,m|
             if klass.is_a?(Array) ? !klass.any?{|kls| v.is_a?(kls)} : !v.is_a?(klass)
-              validation_error_message(m, klass)
+              validates_type_error_message(m, klass)
             end
           end
         end
@@ -338,6 +342,9 @@ module Sequel
         def validation_error_message(message, *args)
           message.is_a?(Proc) ? message.call(*args) : message
         end
+
+        # The validation error message for type validations, for the given class.
+        alias validates_type_error_message validation_error_message
       end
     end
   end

data/lib/sequel/plugins/validation_helpers_generic_type_messages.rb

@@ -0,0 +1,73 @@
+# frozen-string-literal: true
+
+require_relative 'validation_helpers'
+
+module Sequel
+  module Plugins
+    # The validation_helpers_generic_type_messages plugin overrides the default
+    # type validation failure messages in the validation_helpers plugin to be
+    # more generic and understandable by the average user, instead of always
+    # be based on the names of the allowed classes for the type.  For example:
+    #
+    #   # :blob type
+    #   # validation_helpers default: "value is not a valid sequel::sql::blob"
+    #   # with this plugin: "value is not a blob"
+    #
+    #   # :boolean type
+    #   # validation_helpers default: "value is not a valid trueclass or falseclass"
+    #   # with this plugin: "value is not true or false"
+    #
+    #   # :datetime type
+    #   # validation_helpers default: "value is not a valid time or datetime"
+    #   # with this plugin: "value is not a valid timestamp"
+    #
+    #   # custom/database-specific types
+    #   # validation_helpers default: "value is not a valid sequel::class_name"
+    #   # with this plugin: "value is not the expected type"
+    #
+    # It is expected that this plugin will become the default behavior of
+    # validation_helpers in Sequel 6.
+    #
+    # To enable this the use of generic type messages for all models, load this
+    # plugin into Sequel::Model.
+    #
+    #   Sequel::Model.plugin :validation_helpers_generic_type_messages
+    module ValidationHelpersGenericTypeMessages
+      OVERRIDE_PROC = ValidationHelpers::DEFAULT_OPTIONS[:type][:message]
+      private_constant :OVERRIDE_PROC
+
+      TYPE_ERROR_STRINGS = {
+        String => 'is not a string'.freeze,
+        Integer => 'is not an integer'.freeze,
+        Date => 'is not a valid date'.freeze,
+        [Time, DateTime].freeze => 'is not a valid timestamp'.freeze,
+        Sequel::SQLTime => 'is not a valid time'.freeze,
+        [TrueClass, FalseClass].freeze => 'is not true or false'.freeze,
+        Float => 'is not a number'.freeze,
+        BigDecimal => 'is not a number'.freeze,
+        Sequel::SQL::Blob => 'is not a blob'.freeze,
+      }
+      TYPE_ERROR_STRINGS.default = "is not the expected type".freeze
+      TYPE_ERROR_STRINGS.freeze
+      private_constant :TYPE_ERROR_STRINGS
+
+      def self.apply(mod)
+        mod.plugin :validation_helpers
+      end
+
+      module InstanceMethods 
+        private
+
+        # Use a generic error message for type validations.
+        def validates_type_error_message(m, klass)
+          # SEQUEL6: Make this the default behavior in validation_helpers
+          if OVERRIDE_PROC.equal?(m)
+            TYPE_ERROR_STRINGS[klass]
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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 = 67
+  MINOR = 74
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.