sequel 5.60.1 → 5.81.0

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

@@ -3,7 +3,8 @@
 module Sequel
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
-    # instance level inserts and updates.
+    # instance level inserts and updates. This plugin exists for backwards compatibility
+    # and is not recommended for general use.
     #
     # Note that this plugin is unsafe in some circumstances, as it can allow up to
     # 2^N prepared statements to be created for each type of insert and update query, where

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -5,7 +5,8 @@ module Sequel
     # The prepared_statements_safe plugin modifies the model to reduce the number of
     # prepared statements that can be created, by setting as many columns as possible
     # before creating, and by changing +save_changes+ to save all columns instead of
-    # just the changed ones.
+    # just the changed ones. This plugin exists for backwards compatibility
+    # and is not recommended for general use.
     #
     # This plugin depends on the +prepared_statements+ plugin.
     # 

data/lib/sequel/plugins/primary_key_lookup_check_values.rb

@@ -0,0 +1,154 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The primary_key_lookup_check_values plugin typecasts given primary key
+    # values before performing a lookup by primary key. If the given primary
+    # key value cannot be typecasted correctly, the lookup returns nil
+    # without issuing a query.  If the schema for the primary key column
+    # includes minimum and maximum values, this also checks the given value
+    # is not outside the range.  If the given value is outside the allowed
+    # range, the lookup returns nil without issuing a query.
+    #
+    # This affects the following Model methods:
+    #
+    # * Model.[] (when called with non-Hash)
+    # * Model.with_pk
+    # * Model.with_pk!
+    #
+    # It also affects the following Model dataset methods:
+    #
+    # * Dataset#[] (when called with Integer)
+    # * Dataset#with_pk
+    # * dataset#with_pk!
+    # 
+    # Note that this can break working code.  The above methods accept
+    # any filter condition by default, not just primary key values.  The
+    # plugin will handle Symbol, Sequel::SQL::Expression, and
+    # Sequel::LiteralString objects, but code such as the following will break:
+    #
+    #   # Return first Album where primary key is one of the given values
+    #   Album.dataset.with_pk([1, 2, 3])
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support checking primary key values before
+    #   # lookup # (called before loading subclasses)
+    #   Sequel::Model.plugin :primary_key_lookup_check_values
+    #
+    #   # Make the Album class support checking primary key values before lookup
+    #   Album.plugin :primary_key_lookup_check_values
+    module PrimaryKeyLookupCheckValues
+      def self.configure(model)
+        model.instance_exec do
+          setup_primary_key_lookup_check_values if @dataset
+        end
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :setup_primary_key_lookup_check_values)
+
+        Plugins.inherited_instance_variables(self,
+          :@primary_key_type=>nil,
+          :@primary_key_value_range=>nil)
+
+        private
+
+        # Check the given primary key value.  Typecast it to the appropriate
+        # database type if the database type is known.  If it cannot be
+        # typecasted, or the typecasted value is outside the range of column
+        # values, return nil.
+        def _check_pk_lookup_value(pk)
+          return if nil == pk
+          case pk
+          when SQL::Expression, LiteralString, Symbol
+            return pk
+          end
+          return pk unless pk_type = @primary_key_type
+
+          if pk_type.is_a?(Array)
+            return unless pk.is_a?(Array)
+            return unless pk.size == pk_type.size
+            return if pk.any?(&:nil?)
+
+            pk_value_range = @primary_key_value_range
+            i = 0
+            pk.map do |v|
+              if type = pk_type[i]
+                v = _typecast_pk_lookup_value(v, type)
+                return if nil == v
+                if pk_value_range
+                  min, max = pk_value_range[i]
+                  return if min && v < min
+                  return if max && v > max
+                end
+              end
+              i += 1
+              v
+            end
+          elsif pk.is_a?(Array)
+            return
+          elsif nil != (pk = _typecast_pk_lookup_value(pk, pk_type))
+            min, max = @primary_key_value_range
+            return if min && pk < min
+            return if max && pk > max
+            pk
+          end
+        end
+
+        # Typecast the value to the appropriate type,
+        # returning nil if it cannot be typecasted.
+        def _typecast_pk_lookup_value(value, type)
+          db.typecast_value(type, value)
+        rescue InvalidValue
+          nil
+        end
+
+        # Skip the primary key lookup if the typecasted and checked
+        # primary key value is nil.
+        def primary_key_lookup(pk)
+          unless nil == (pk = _check_pk_lookup_value(pk))
+            super
+          end
+        end
+
+        # Setup the primary key type and value range used for checking
+        # primary key values during lookup.
+        def setup_primary_key_lookup_check_values
+          if primary_key.is_a?(Array)
+            types = []
+            value_ranges = []
+            primary_key.each do |pk|
+              type, min, max = _type_min_max_values_for_column(pk)
+              types << type
+              value_ranges << ([min, max].freeze if min || max)
+            end
+            @primary_key_type = (types.freeze if types.any?)
+            @primary_key_value_range = (value_ranges.freeze if @primary_key_type && value_ranges.any?)
+          else
+            @primary_key_type, min, max = _type_min_max_values_for_column(primary_key)
+            @primary_key_value_range = ([min, max].freeze if @primary_key_type && (min || max))
+          end
+        end
+
+        # Return the type, min_value, and max_value schema entries
+        # for the column, if they exist.
+        def _type_min_max_values_for_column(column)
+          if schema = db_schema[column]
+            schema.values_at(:type, :min_value, :max_value)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Skip the primary key lookup if the typecasted and checked
+        # primary key value is nil.
+        def with_pk(pk)
+          unless nil == (pk = model.send(:_check_pk_lookup_value, pk))
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/rcte_tree.rb

@@ -71,6 +71,8 @@ module Sequel
     #              (default: :t)
     # :level_alias :: The symbol identifier to use when eagerly loading descendants
     #                 up to a given level (default: :x_level_x)
+    # :union_all :: Whether to use UNION ALL or UNION with the recursive
+    #               common table expression (default: true)
     module RcteTree
       # Create the appropriate parent, children, ancestors, and descendants
       # associations for the model.
@@ -80,6 +82,7 @@ module Sequel
         opts = opts.dup
         opts[:class] = model
         opts[:methods_module] = Module.new
+        opts[:union_all] = opts[:union_all].nil? ? true : opts[:union_all]
         model.send(:include, opts[:methods_module])
         
         key = opts[:key] ||= :parent_id
@@ -142,7 +145,7 @@ module Sequel
           model.from(SQL::AliasedExpression.new(t, table_alias)).
            with_recursive(t, col_aliases ? base_ds.select(*col_aliases) : base_ds.select_all,
             recursive_ds.select(*c_all),
-            :args=>col_aliases)
+            :args=>col_aliases, union_all: opts[:union_all])
         end
         aal = Array(a[:after_load])
         aal << proc do |m, ancs|
@@ -191,7 +194,7 @@ module Sequel
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
             with_recursive(t, base_case, recursive_case,
-             :args=>((key_aliases + col_aliases) if col_aliases))
+             :args=>((key_aliases + col_aliases) if col_aliases), union_all: opts[:union_all])
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
           model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
@@ -240,7 +243,7 @@ module Sequel
           model.from(SQL::AliasedExpression.new(t, table_alias)).
            with_recursive(t, col_aliases ? base_ds.select(*col_aliases) : base_ds.select_all,
             recursive_ds.select(*c_all),
-            :args=>col_aliases)
+            :args=>col_aliases, union_all: opts[:union_all])
           end
         dal = Array(d[:after_load])
         dal << proc do |m, descs|
@@ -299,7 +302,7 @@ module Sequel
           table_alias = model.dataset.schema_and_table(model.table_name)[1].to_sym
           ds = model.from(SQL::AliasedExpression.new(t, table_alias)).
             with_recursive(t, base_case, recursive_case,
-              :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases))
+              :args=>((key_aliases + col_aliases + (level ? [la] : [])) if col_aliases), union_all: opts[:union_all])
           ds = r.apply_eager_dataset_changes(ds)
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
           model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -253,6 +253,14 @@ module Sequel
 
         private
 
+        # Limit tactical eager loading objects to objects that support the same association.
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          name = opts[:name]
+          objects.select!{|x| x.model.association_reflections.include?(name)}
+          objects
+        end
+
         # Don't allow use of prepared statements.
         def use_prepared_statements_for?(type)
           false

data/lib/sequel/plugins/sql_comments.rb

@@ -12,7 +12,7 @@ module Sequel
     #   # SELECT * FROM albums WHERE (id = 1) LIMIT 1
     #   # -- model:Album,method_type:class,method:[]
     #
-    #   album.update(:name=>'A')
+    #   album.update(name: 'A')
     #   # UPDATE albums SET name = 'baz' WHERE (id = 1)
     #   # -- model:Album,method_type:instance,method:update
     #

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

@@ -152,23 +152,23 @@ module Sequel
           name = opts[:name]
           eager_reload = dynamic_opts[:eager_reload]
           if (!associations.include?(name) || eager_reload) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
-            begin
-              objects = if eager_reload
-                retrieved_with.reject(&:frozen?)
-              else
-                retrieved_with.reject{|x| x.frozen? || x.associations.include?(name)}
-              end
-              retrieved_by.send(:eager_load, objects, name=>dynamic_opts[:eager] || OPTS)
-            rescue Sequel::UndefinedAssociation
-              # This can happen if class table inheritance is used and the association
-              # is only defined in a subclass.  This particular instance can use the
-              # association, but it can't be eagerly loaded as the parent class doesn't
-              # have access to the association, and that's the class doing the eager loading.
-              nil
-            end
+            retrieved_by.send(:eager_load, _filter_tactical_eager_load_objects(:eager_reload=>eager_reload, :name=>name), {name=>dynamic_opts[:eager] || OPTS}, model)
           end
           super
         end
+
+        # Filter the objects used when tactical eager loading.
+        # By default, this removes frozen objects and objects that alreayd have the association loaded
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          if opts[:eager_reload]
+            objects.reject!(&:frozen?)
+          else
+            name = opts[:name]
+            objects.reject!{|x| x.frozen? || x.associations.include?(name)}
+          end
+          objects
+        end
       end
 
       module DatasetMethods

data/lib/sequel/plugins/validate_associated.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The validates_associated plugin allows you to validate associated
+    # The validate_associated plugin allows you to validate associated
     # objects.  It also offers the ability to delay the validation of
     # associated objects until the current object is validated.
     # If the associated object is invalid, validation error messages
@@ -54,22 +54,32 @@ module Sequel
           return if reflection[:validate] == false
           association = reflection[:name]
           if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])
-            # There could be a presence validation on the foreign key in the associated model,
-            # which will fail if we validate before saving the current object.  If there is
-            # no value for the foreign key, set it to the current primary key value, or a dummy
-            # value of 0 if we haven't saved the current object.
             p_key = pk unless pk.is_a?(Array)
-            obj.values[key] = p_key || 0
-            key = nil if p_key
+            if p_key
+              obj.values[key] = p_key
+            else
+              ignore_key_errors = true
+            end
           end
-          obj.errors.full_messages.each{|m| errors.add(association, m)} unless obj.valid?
-          if key && !pk_val
-            # If we used a dummy value of 0, remove it so it doesn't accidently remain.
-            obj.values.delete(key)
+
+          unless obj.valid?
+            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
+              # in the current object (which may not be available until after the current
+              # object is saved).
+              obj.errors.delete(key)
+              obj.errors.delete_if{|k,| Array === k && k.include?(key)}
+            end
+
+            obj.errors.full_messages.each do |m|
+              errors.add(association, m)
+            end
           end
+
+          nil
         end
       end
     end
   end
 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"}},
@@ -83,7 +87,9 @@ module Sequel
         :integer=>{:message=>lambda{"is not a number"}},
         :length_range=>{:message=>lambda{|range| "is too short or too long"}},
         :max_length=>{:message=>lambda{|max| "is longer than #{max} characters"}, :nil_message=>lambda{"is not present"}},
+        :max_value=>{:message=>lambda{|max| "is greater than maximum allowed value"}},
         :min_length=>{:message=>lambda{|min| "is shorter than #{min} characters"}},
+        :min_value=>{:message=>lambda{|min| "is less than minimum allowed value"}},
         :not_null=>{:message=>lambda{"is not present"}},
         :no_null_byte=>{:message=>lambda{"contains a null byte"}},
         :numeric=>{:message=>lambda{"is not a number"}},
@@ -141,11 +147,29 @@ module Sequel
           end
         end
 
+        # Check that the attribute values are not greater that the given maximum value.
+        # Does not perform validation if attribute value is nil.
+        # You should only call this if you have checked the attribute value has the expected type.
+        def validates_max_value(max, atts, opts=OPTS)
+          validatable_attributes_for_type(:max_value, atts, opts) do |a,v,m|
+            validation_error_message(m, max) if !v.nil? && v > max
+          end
+        end
+
         # Check that the attribute values are not shorter than the given min length.
         def validates_min_length(min, atts, opts=OPTS)
           validatable_attributes_for_type(:min_length, atts, opts){|a,v,m| validation_error_message(m, min) if v.nil? || v.length < min}
         end
 
+        # Check that the attribute values are not less that the given minimum value.
+        # Does not perform validation if attribute value is nil.
+        # You should only call this if you have checked the attribute value has the expected type.
+        def validates_min_value(min, atts, opts=OPTS)
+          validatable_attributes_for_type(:min_value, atts, opts) do |a,v,m|
+            validation_error_message(m, min) if !v.nil? && v < min
+          end
+        end
+
         # Check attribute value(s) are not NULL/nil.
         def validates_not_null(atts, opts=OPTS)
           validatable_attributes_for_type(:not_null, atts, opts){|a,v,m| validation_error_message(m) if v.nil?}
@@ -191,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
@@ -271,7 +295,7 @@ module Sequel
               h = ds.joined_dataset? ? qualified_pk_hash : pk_hash
               ds = ds.exclude(h)
             end
-            errors.add(a, message) unless ds.count == 0
+            errors.add(a, message) unless ds.empty?
           end
         end
         
@@ -318,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