sequel 5.60.1 → 5.62.0

data/lib/sequel/extensions/pg_extended_integer_support.rb

@@ -0,0 +1,116 @@
+# frozen-string-literal: true
+#
+# The pg_extended_integer_support extension supports literalizing
+# Ruby integers outside of PostgreSQL bigint range on PostgreSQL.
+# Sequel by default will raise exceptions when
+# literalizing such integers, as PostgreSQL would treat them
+# as numeric type values instead of integer/bigint type values
+# if unquoted, which can result in unexpected negative performance
+# (e.g. forcing sequential scans when index scans would be used for
+# an integer/bigint type).
+#
+# To load the extension into a Dataset (this returns a new Dataset):
+#
+#   dataset = dataset.extension(:pg_extended_integer_support)
+#
+# To load the extension into a Database, so it affects all of the
+# Database's datasets:
+#
+#   DB.extension :pg_extended_integer_support
+#
+# By default, the extension will quote integers outside
+# bigint range:
+#
+#   DB.literal(2**63) # => "'9223372036854775808'"
+#
+# Quoting the value treats the type as unknown:
+#
+#   DB.get{pg_typeof(2**63)} # => 'unknown'
+#
+# PostgreSQL will implicitly cast the unknown type to the appropriate
+# database type, raising an error if it cannot be casted. Be aware this
+# can result in the integer value being implicitly casted to text or
+# any other PostgreSQL type:
+#
+#   # Returns a string, not an integer:
+#   DB.get{2**63}
+#   # => "9223372036854775808"
+#
+# You can use the Dataset#integer_outside_bigint_range_strategy method
+# with the value +:raw+ to change the strategy to not quote the variable:
+#
+#  DB.dataset.
+#    integer_outside_bigint_range_strategy(:raw).
+#    literal(2**63)
+#  # => "9223372036854775808"
+#
+# Note that not quoting the value will result in PostgreSQL treating
+# the type as numeric instead of integer:
+#
+#  DB.dataset.
+#    integer_outside_bigint_range_strategy(:raw).
+#    get{pg_typeof(2**63)}
+#  # => "numeric"
+#
+# The +:raw+ behavior was Sequel's historical behavior, but unless
+# you fully understand the reprecussions of PostgreSQL using a
+# numeric type for integer values, you should not use it.
+#
+# To get the current default behavior of raising an exception for
+# integers outside of PostgreSQL bigint range, you can use a strategy
+# of +:raise+.
+#
+# To specify a default strategy for handling integers outside
+# bigint range that applies to all of a Database's datasets, you can
+# use the +:integer_outside_bigint_range_strategy+ Database option with
+# a value of +:raise+ or +:raw+:
+#
+#   DB.opts[:integer_outside_bigint_range_strategy] = :raw
+#
+# The Database option will be used as a fallback if you did not call
+# the Dataset#integer_outside_bigint_range_strategy method to specify
+# a strategy for the dataset.
+#
+# Related module: Sequel::Postgres::ExtendedIntegerSupport
+
+#
+module Sequel
+  module Postgres
+    module ExtendedIntegerSupport
+      # Set the strategy for handling integers outside PostgreSQL
+      # bigint range.  Supported values:
+      #
+      # :quote :: Quote the integer value. PostgreSQL will treat
+      #           the integer as a unknown type, implicitly casting
+      #           to any other type as needed. This is the default
+      #           value when using the pg_extended_integer_support
+      #           extension.
+      # :raise :: Raise error when attempting to literalize the integer
+      #           (the default behavior of Sequel on PostgreSQL when
+      #           not using the pg_extended_integer_support extension).
+      # :raw :: Use raw integer value without quoting. PostgreSQL
+      #         will treat the integer as a numeric. This was Sequel's
+      #         historical behavior, but it is unlikely to be desired.
+      def integer_outside_bigint_range_strategy(strategy)
+        clone(:integer_outside_bigint_range_strategy=>strategy)
+      end
+
+      private
+
+      # Handle integers outside the bigint range by using
+      # the configured strategy.
+      def literal_integer_outside_bigint_range(v)
+        case @opts[:integer_outside_bigint_range_strategy] || @db.opts[:integer_outside_bigint_range_strategy]
+        when :raise
+          super
+        when :raw
+          v.to_s
+        else # when :quote
+          "'#{v}'"
+        end
+      end
+    end
+  end
+
+  Dataset.register_extension(:pg_extended_integer_support, Postgres::ExtendedIntegerSupport)
+end

data/lib/sequel/extensions/pg_hstore.rb

@@ -280,6 +280,11 @@ module Sequel
         str
       end
 
+      # Allow automatic parameterization.
+      def sequel_auto_param_type(ds)
+        "::hstore"
+      end
+
       private
 
       # Return a new hash based on the input hash with string

data/lib/sequel/extensions/pg_inet.rb

@@ -75,16 +75,6 @@ module Sequel
 
       private
 
-      # Handle inet[]/cidr[] types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when IPAddr
-          "\"#{a.to_s}/#{a.instance_variable_get(:@mask_addr).to_s(2).count('1')}\""
-        else
-          super
-        end
-      end
-
       # Make the column type detection recognize the inet and cidr types.
       def schema_column_type(db_type)
         case db_type
@@ -111,7 +101,7 @@ module Sequel
         when IPAddr
           value
         when String
-          IPAddr.new(value)
+          IPAddr.new(typecast_check_string_length(value, 100))
         else
           raise Sequel::InvalidValue, "invalid value for inet/cidr: #{value.inspect}"
         end
@@ -121,6 +111,15 @@ module Sequel
     module InetDatasetMethods
       private
 
+      # Allow auto parameterization of IPAddr instances.
+      def auto_param_type_fallback(v)
+        if defined?(super) && (type = super)
+          type
+        elsif IPAddr === v
+          "::inet"
+        end
+      end
+
       # Convert IPAddr value to a string and append a literal version
       # of the string to the sql.
       def literal_other_append(sql, value)

data/lib/sequel/extensions/pg_interval.rb

@@ -163,16 +163,6 @@ module Sequel
 
       private
 
-      # Handle arrays of interval types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when ActiveSupport::Duration
-          "\"#{IntervalDatabaseMethods.literal_duration(a)}\""
-        else
-          super
-        end
-      end
-
       # Set the :ruby_default value if the default value is recognized as an interval.
       def schema_post_process(_)
         super.each do |a|
@@ -197,7 +187,7 @@ module Sequel
         when Numeric
           ActiveSupport::Duration.new(value, [[:seconds, value]])
         when String
-          PARSER.call(value)
+          PARSER.call(typecast_check_string_length(value, 1000))
         else
           raise Sequel::InvalidValue, "invalid value for interval type: #{value.inspect}"
         end
@@ -207,6 +197,15 @@ module Sequel
     module IntervalDatasetMethods
       private
 
+      # Allow auto parameterization of ActiveSupport::Duration instances.
+      def auto_param_type_fallback(v)
+        if defined?(super) && (type = super)
+          type
+        elsif ActiveSupport::Duration === v
+          "::interval"
+        end
+      end
+
       # Handle literalization of ActiveSupport::Duration objects, treating them as
       # PostgreSQL intervals.
       def literal_other_append(sql, v)

data/lib/sequel/extensions/pg_json.rb

@@ -142,6 +142,11 @@ module Sequel
           ds.literal_append(sql, Sequel.object_to_json(self))
           sql << '::json'
         end
+
+        # Allow automatic parameterization.
+        def sequel_auto_param_type(ds)
+          "::json"
+        end
       end
 
       jsonb_class = Class.new(base_class) do
@@ -151,6 +156,11 @@ module Sequel
           ds.literal_append(sql, Sequel.object_to_json(self))
           sql << '::jsonb'
         end
+
+        # Allow automatic parameterization.
+        def sequel_auto_param_type(ds)
+          "::jsonb"
+        end
       end
 
       const_set(:"JSON#{name}Base", base_class)
@@ -424,16 +434,6 @@ module Sequel
         end
       end
 
-      # Handle json[] and jsonb[] types in bound variables.
-      def bound_variable_array(a)
-        case a
-        when JSONObject, JSONBObject
-          "\"#{Sequel.object_to_json(a).gsub('"', '\\"')}\""
-        else
-          super
-        end
-      end
-
       # Make the column type detection recognize the json types.
       def schema_column_type(db_type)
         case db_type

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,15 +123,6 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
-# On PostgreSQL 15+, the <tt>IS [NOT] JSON</tt> operator is supported:
-#
-#   j.is_json                              # j IS JSON
-#   j.is_json(type: :object)               # j IS JSON OBJECT
-#   j.is_json(type: :object, unique: true) # j IS JSON OBJECT WITH UNIQUE
-#   j.is_not_json                          # j IS NOT JSON
-#   j.is_json(type: :array)                # j IS NOT JSON ARRAY
-#   j.is_json(unique: true)                # j IS NOT JSON WITH UNIQUE
-#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -160,18 +151,6 @@ module Sequel
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
       GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
 
-      IS_JSON = ["(".freeze, " IS JSON".freeze, "".freeze, ")".freeze].freeze
-      IS_NOT_JSON = ["(".freeze, " IS NOT JSON".freeze, "".freeze, ")".freeze].freeze
-      EMPTY_STRING = Sequel::LiteralString.new('').freeze
-      WITH_UNIQUE = Sequel::LiteralString.new(' WITH UNIQUE').freeze
-      IS_JSON_MAP = {
-        nil => EMPTY_STRING,
-        :value => Sequel::LiteralString.new(' VALUE').freeze,
-        :scalar => Sequel::LiteralString.new(' SCALAR').freeze,
-        :object => Sequel::LiteralString.new(' OBJECT').freeze,
-        :array => Sequel::LiteralString.new(' ARRAY').freeze
-      }.freeze
-
       # Get JSON array element or object field as json.  If an array is given,
       # gets the object at the specified path.
       #
@@ -254,30 +233,6 @@ module Sequel
         end
       end
 
-      # Return whether the json object can be parsed as JSON.
-      #
-      # Options:
-      # :type :: Check whether the json object can be parsed as a specific type
-      #          of JSON (:value, :scalar, :object, :array).
-      # :unique :: Check JSON objects for unique keys.
-      #
-      #   json_op.is_json                 # json IS JSON
-      #   json_op.is_json(type: :object)  # json IS JSON OBJECT
-      #   json_op.is_json(unique: true)   # json IS JSON WITH UNIQUE
-      def is_json(opts=OPTS)
-        _is_json(IS_JSON, opts)
-      end
-
-      # Return whether the json object cannot be parsed as JSON. The opposite
-      # of #is_json. See #is_json for options.
-      #
-      #   json_op.is_not_json                 # json IS NOT JSON
-      #   json_op.is_not_json(type: :object)  # json IS NOT JSON OBJECT
-      #   json_op.is_not_json(unique: true)   # json IS NOT JSON WITH UNIQUE
-      def is_not_json(opts=OPTS)
-        _is_json(IS_NOT_JSON, opts)
-      end
-
       # Returns a set of keys AS text in the json object.
       #
       #   json_op.keys # json_object_keys(json)
@@ -331,13 +286,6 @@ module Sequel
 
       private
 
-      # Internals of IS [NOT] JSON support
-      def _is_json(lit_array, opts)
-        raise Error, "invalid is_json :type option: #{opts[:type].inspect}" unless type = IS_JSON_MAP[opts[:type]]
-        unique = opts[:unique] ? WITH_UNIQUE : EMPTY_STRING
-        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(lit_array, [self, type, unique]))
-      end
-
       # Return a placeholder literal with the given str and args, wrapped
       # in an JSONOp or JSONBOp, used by operators that return json or jsonb.
       def json_op(str, args)

data/lib/sequel/extensions/pg_multirange.rb

@@ -220,16 +220,6 @@ module Sequel
 
         private
 
-        # Handle arrays of multirange types in bound variables.
-        def bound_variable_array(a)
-          case a
-          when PGMultiRange
-            "\"#{bound_variable_arg(a, nil)}\""
-          else
-            super
-          end
-        end
-
         # Recognize the registered database multirange types.
         def schema_column_type(db_type)
           @pg_multirange_schema_types[db_type] || super
@@ -346,6 +336,11 @@ module Sequel
          
         val << "}"
       end
+
+      # Allow automatic parameterization.
+      def sequel_auto_param_type(ds)
+        "::#{db_type}"
+      end
     end
   end
 

data/lib/sequel/extensions/pg_range.rb

@@ -233,16 +233,6 @@ module Sequel
 
         private
 
-        # Handle arrays of range types in bound variables.
-        def bound_variable_array(a)
-          case a
-          when PGRange, Range
-            "\"#{bound_variable_arg(a, nil)}\""
-          else
-            super
-          end
-        end
-
         # Recognize the registered database range types.
         def schema_column_type(db_type)
           @pg_range_schema_types[db_type] || super
@@ -282,7 +272,7 @@ module Sequel
           when Range
             PGRange.from_range(value, parser.db_type)
           when String
-            parser.call(value)
+            parser.call(typecast_check_string_length(value, 100))
           else
             raise Sequel::InvalidValue, "invalid value for range type: #{value.inspect}"
           end
@@ -491,6 +481,11 @@ module Sequel
         end
       end
 
+      # Allow automatic parameterization for ranges with types.
+      def sequel_auto_param_type(ds)
+        "::#{db_type}" if db_type
+      end
+
       private
 
       # Escape common range types.  Instead of quoting, just backslash escape all

data/lib/sequel/extensions/pg_row.rb

@@ -136,6 +136,15 @@ module Sequel
             ds.quote_schema_table_append(sql, db_type)
           end
         end
+
+        # Allow automatic parameterization if all values support it.
+        def sequel_auto_param_type(ds)
+          if db_type && all?{|v| nil == v || ds.send(:auto_param_type, v)}
+            s = String.new << "::"
+            ds.quote_schema_table_append(s, db_type)
+            s
+          end
+        end
       end
 
       # Class for row-valued/composite types that are treated as hashes.
@@ -208,6 +217,15 @@ module Sequel
             ds.quote_schema_table_append(sql, db_type)
           end
         end
+
+        # Allow automatic parameterization if all values support it.
+        def sequel_auto_param_type(ds)
+          if db_type && all?{|_,v| nil == v || ds.send(:auto_param_type, v)}
+            s = String.new << "::"
+            ds.quote_schema_table_append(s, db_type)
+            s
+          end
+        end
       end
 
       ROW_TYPE_CLASSES = [HashRow, ArrayRow].freeze
@@ -519,19 +537,6 @@ module Sequel
 
         private
 
-        # Format composite types used in bound variable arrays.
-        def bound_variable_array(arg)
-          case arg
-          when ArrayRow
-            "\"(#{arg.map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          when HashRow
-            arg.check_columns!
-            "\"(#{arg.values_at(*arg.columns).map{|v| bound_variable_array(v) if v}.join(',').gsub(/("|\\)/, '\\\\\1')})\""
-          else
-            super
-          end
-        end
-
         # Make the column type detection handle registered row types.
         def schema_column_type(db_type)
           if type = @row_schema_types[db_type]

data/lib/sequel/model/associations.rb

@@ -276,7 +276,7 @@ module Sequel
 
           if eo[:no_results]
             no_results = true
-          elsif eo[:eager_block] || eo[:loader] == false
+          elsif eo[:eager_block] || eo[:loader] == false || !use_placeholder_loader?
             ds = eager_loading_dataset(eo)
 
             strategy = ds.opts[:eager_limit_strategy] || strategy
@@ -299,6 +299,11 @@ module Sequel
             strategy = :ruby if strategy == :correlated_subquery
             strategy = nil if strategy == :ruby && assign_singular?
             objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
+
+            if strategy == :window_function
+              delete_rn = ds.row_number_column 
+              objects.each{|obj| obj.values.delete(delete_rn)}
+            end
           elsif strategy == :union
             objects = []
             ds = associated_dataset
@@ -817,7 +822,7 @@ module Sequel
 
         # Whether the placeholder loader can be used to load the association.
         def use_placeholder_loader?
-          self[:use_placeholder_loader]
+          self[:use_placeholder_loader] && _associated_dataset.supports_placeholder_literalizer?
         end
       end
     

data/lib/sequel/model/base.rb

@@ -606,6 +606,7 @@ module Sequel
           @db_schema = get_db_schema
         end
 
+        @fast_pk_lookup_sql = @fast_instance_delete_sql = nil unless @dataset.supports_placeholder_literalizer?
         reset_instance_dataset
         self
       end
@@ -1141,7 +1142,7 @@ module Sequel
       #
       #   Artist[1] === Artist[1] # => true
       #   Artist.new === Artist.new # => false
-      #   Artist[1].set(:name=>'Bob') === Artist[1] # => true
+      #   Artist[1].set(name: 'Bob') === Artist[1] # => true
       def ===(obj)
         case pkv = pk
         when nil
@@ -1160,7 +1161,7 @@ module Sequel
       #
       #   Artist[1].pk_equal?(Artist[1]) # => true
       #   Artist.new.pk_equal?(Artist.new) # => false
-      #   Artist[1].set(:name=>'Bob').pk_equal?(Artist[1]) # => true
+      #   Artist[1].set(name: 'Bob').pk_equal?(Artist[1]) # => true
       alias pk_equal? ===
 
       # class is defined in Object, but it is also a keyword,
@@ -1232,7 +1233,7 @@ module Sequel
       #
       #   Artist[1] == Artist[1] # => true
       #   Artist.new == Artist.new # => true
-      #   Artist[1].set(:name=>'Bob') == Artist[1] # => false
+      #   Artist[1].set(name: 'Bob') == Artist[1] # => false
       def eql?(obj)
         (obj.class == model) && (obj.values == @values)
       end
@@ -1334,13 +1335,13 @@ module Sequel
       #   a = Artist[1]
       #   Artist.db.transaction do
       #     a.lock!
-      #     a.update(:name=>'A')
+      #     a.update(name: 'A')
       #   end
       #
       #   a = Artist[2]
       #   Artist.db.transaction do
       #     a.lock!('FOR NO KEY UPDATE')
-      #     a.update(:name=>'B')
+      #     a.update(name: 'B')
       #   end
       def lock!(style=:update)
         _refresh(this.lock_style(style)) unless new?

data/lib/sequel/plugins/auto_validations.rb

@@ -9,14 +9,16 @@ module Sequel
     # 2. not_null validations on NOT NULL columns (optionally, presence validations)
     # 3. unique validations on columns or sets of columns with unique indexes
     # 4. max length validations on string columns
+    # 5. no null byte validations on string columns
+    # 6. minimum and maximum values on columns
     #
-    # To determine the columns to use for the type/not_null/max_length validations,
+    # To determine the columns to use for the type/not_null/max_length/no_null_byte/max_value/min_value validations,
     # the plugin looks at the database schema for the model's table.  To determine
     # the unique validations, Sequel looks at the indexes on the table.  In order
     # for this plugin to be fully functional, the underlying database adapter needs
     # to support both schema and index parsing.  Additionally, unique validations are
     # only added for models that select from a simple table, they are not added for models
-    # that select from a subquery or joined dataset.
+    # that select from a subquery.
     #
     # This plugin uses the validation_helpers plugin underneath to implement the
     # validations.  It does not allow for any per-column validation message
@@ -50,7 +52,7 @@ module Sequel
     #
     #   Model.plugin :auto_validations, unique_opts: {only_if_modified: true}
     #
-    # This works for unique_opts, max_length_opts, schema_types_opts,
+    # This works for unique_opts, max_length_opts, schema_types_opts, max_value_opts, min_value_opts, no_null_byte_opts,
     # explicit_not_null_opts, and not_null_opts.
     #
     # If you only want auto_validations to add validations to columns that do not already
@@ -72,6 +74,19 @@ module Sequel
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
       NO_NULL_BYTE_OPTIONS = MAX_LENGTH_OPTIONS
+      MAX_VALUE_OPTIONS = {:from=>:values, :allow_nil=>true, :skip_invalid=>true}.freeze
+      MIN_VALUE_OPTIONS = MAX_VALUE_OPTIONS
+      AUTO_VALIDATE_OPTIONS = {
+        :no_null_byte=>NO_NULL_BYTE_OPTIONS,
+        :not_null=>NOT_NULL_OPTIONS,
+        :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
+        :max_length=>MAX_LENGTH_OPTIONS,
+        :max_value=>MAX_VALUE_OPTIONS,
+        :min_value=>MIN_VALUE_OPTIONS,
+        :schema_types=>SCHEMA_TYPES_OPTIONS,
+        :unique=>UNIQUE_OPTIONS
+      }.freeze
+
       EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
@@ -82,17 +97,11 @@ module Sequel
           @auto_validate_not_null_columns = []
           @auto_validate_explicit_not_null_columns = []
           @auto_validate_max_length_columns = []
+          @auto_validate_max_value_columns = []
+          @auto_validate_min_value_columns = []
           @auto_validate_unique_columns = []
           @auto_validate_types = true
-
-          @auto_validate_options = {
-              :no_null_byte=>NO_NULL_BYTE_OPTIONS,
-              :not_null=>NOT_NULL_OPTIONS,
-              :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
-              :max_length=>MAX_LENGTH_OPTIONS,
-              :schema_types=>SCHEMA_TYPES_OPTIONS,
-              :unique=>UNIQUE_OPTIONS
-          }.freeze
+          @auto_validate_options = AUTO_VALIDATE_OPTIONS
         end
       end
 
@@ -105,7 +114,7 @@ module Sequel
           end
 
           h = @auto_validate_options.dup
-          [:not_null, :explicit_not_null, :max_length, :no_null_byte, :schema_types, :unique].each do |type|
+          [:not_null, :explicit_not_null, :max_length, :max_value, :min_value, :no_null_byte, :schema_types, :unique].each do |type|
             if type_opts = opts[:"#{type}_opts"]
               h[type] = h[type].merge(type_opts).freeze
             end
@@ -135,6 +144,14 @@ module Sequel
         # pairs, with the first entry being the column name and second entry being the maximum length.
         attr_reader :auto_validate_max_length_columns
 
+        # The columns with automatch max value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the maximum value.
+        attr_reader :auto_validate_max_value_columns
+
+        # The columns with automatch min value validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the minimum value.
+        attr_reader :auto_validate_min_value_columns
+
         # The columns or sets of columns with automatic unique validations
         attr_reader :auto_validate_unique_columns
 
@@ -148,6 +165,8 @@ module Sequel
           :@auto_validate_not_null_columns=>:dup,
           :@auto_validate_explicit_not_null_columns=>:dup,
           :@auto_validate_max_length_columns=>:dup,
+          :@auto_validate_max_value_columns=>:dup,
+          :@auto_validate_min_value_columns=>:dup,
           :@auto_validate_unique_columns=>:dup,
           :@auto_validate_options => :dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
@@ -168,18 +187,23 @@ module Sequel
           @auto_validate_not_null_columns.freeze
           @auto_validate_explicit_not_null_columns.freeze
           @auto_validate_max_length_columns.freeze
+          @auto_validate_max_value_columns.freeze
+          @auto_validate_min_value_columns.freeze
           @auto_validate_unique_columns.freeze
 
           super
         end
 
         # Skip automatic validations for the given validation type
-        # (:not_null, :types, :unique, :max_length, :no_null_byte).
+        # (:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value).
         # If :all is given as the type, skip all auto validations.
+        #
+        # Skipping types validation automatically skips max_value and min_value validations,
+        # since those validations require valid types.
         def skip_auto_validations(type)
           case type
           when :all
-            [:not_null, :no_null_byte, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
+            [:not_null, :no_null_byte, :types, :unique, :max_length, :max_value, :min_value].each{|v| skip_auto_validations(v)}
           when :not_null
             auto_validate_not_null_columns.clear
             auto_validate_explicit_not_null_columns.clear
@@ -199,6 +223,8 @@ module Sequel
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
           @auto_validate_max_length_columns = db_schema.select{|col, sch| sch[:type] == :string && sch[:max_length].is_a?(Integer)}.map{|col, sch| [col, sch[:max_length]]}
+          @auto_validate_max_value_columns = db_schema.select{|col, sch| sch[:max_value]}.map{|col, sch| [col, sch[:max_value]]}
+          @auto_validate_min_value_columns = db_schema.select{|col, sch| sch[:min_value]}.map{|col, sch| [col, sch[:min_value]]}
           @auto_validate_no_null_byte_columns = db_schema.select{|_, sch| sch[:type] == :string}.map{|col, _| col}
           table = dataset.first_source_table
           @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
@@ -248,6 +274,18 @@ module Sequel
 
           unless skip.include?(:types) || !model.auto_validate_types?
             validates_schema_types(keys, opts[:schema_types])
+
+            unless skip.include?(:max_value) || ((max_value_columns = model.auto_validate_max_value_columns).empty?)
+              max_value_columns.each do |col, max|
+                validates_max_value(max, col, opts[:max_value])
+              end
+            end
+
+            unless skip.include?(:min_value) || ((min_value_columns = model.auto_validate_min_value_columns).empty?)
+              min_value_columns.each do |col, min|
+                validates_min_value(min, col, opts[:min_value])
+              end
+            end
           end
 
           unless skip.include?(:unique)