sequel 5.39.0 → 5.72.0

data/lib/sequel/model/base.rb

@@ -508,7 +508,9 @@ module Sequel
 
         m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
+      # :nocov:
       ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
+      # :nocov:
 
       # Returns primary key attribute hash.  If using a composite primary key
       # value such be an array with values for each primary key in the correct
@@ -604,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
@@ -678,24 +681,26 @@ module Sequel
   
       private
       
-      # Yield to the passed block and if do_raise is false, swallow all errors other than DatabaseConnectionErrors.
+      # Yield to the passed block and if do_raise is false, swallow Sequel::Errors other than DatabaseConnectionError
+      # and DatabaseDisconnectError.
       def check_non_connection_error(do_raise=require_valid_table)
-        begin
-          db.transaction(:savepoint=>:only){yield}
-        rescue Sequel::DatabaseConnectionError
-          raise
-        rescue Sequel::Error
-          raise if do_raise
-        end
+        db.transaction(:savepoint=>:only){yield}
+      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
+        raise
+      rescue Sequel::Error
+        raise if do_raise
       end
 
       # Convert the given object to a Dataset that should be used as
       # this model's dataset.
       def convert_input_dataset(ds)
         case ds
-        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
           self.simple_table = db.literal(ds).freeze
           ds = db.from(ds)
+        when SQL::AliasedExpression, LiteralString
+          self.simple_table = nil
+          ds = db.from(ds)
         when Dataset
           ds = ds.from_self(:alias=>ds.first_source) if ds.joined_dataset?
 
@@ -727,8 +732,14 @@ module Sequel
         im = instance_methods
         overridable_methods_module.module_eval do
           meth = :"#{column}="
-          define_method(column){self[column]} unless im.include?(column)
-          define_method(meth){|v| self[column] = v} unless im.include?(meth)
+          unless im.include?(column)
+            define_method(column){self[column]}
+            alias_method(column, column)
+          end
+          unless im.include?(meth)
+            define_method(meth){|v| self[column] = v}
+            alias_method(meth, meth)
+          end
         end
       end
   
@@ -741,8 +752,14 @@ module Sequel
         im = instance_methods
         columns.each do |column|
           meth = :"#{column}="
-          overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__) unless im.include?(column)
-          overridable_methods_module.module_eval("def #{meth}(v); self[:#{column}] = v end", __FILE__, __LINE__) unless im.include?(meth)
+          unless im.include?(column)
+            overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__)
+            overridable_methods_module.send(:alias_method, column, column)
+          end
+          unless im.include?(meth)
+            overridable_methods_module.module_eval("def #{meth}(v); self[:#{column}] = v end", __FILE__, __LINE__)
+            overridable_methods_module.send(:alias_method, meth, meth)
+          end
         end
       end
   
@@ -757,7 +774,10 @@ module Sequel
         else
           define_singleton_method(meth){|*args, &block| dataset.public_send(meth, *args, &block)}
         end
+        singleton_class.send(:alias_method, meth, meth)
+        # :nocov:
         singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -769,7 +789,7 @@ module Sequel
         schema_hash = {}
         ds_opts = dataset.opts
         get_columns = proc{check_non_connection_error{columns} || []}
-        schema_array = check_non_connection_error(false){db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
+        schema_array = get_db_schema_array(reload) if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
 
@@ -806,6 +826,12 @@ module Sequel
         schema_hash
       end
 
+      # Get the array of schema information for the dataset.  Returns nil if
+      # the schema information cannot be determined.
+      def get_db_schema_array(reload)
+        check_non_connection_error(false){db.schema(dataset, :reload=>reload)}
+      end
+
       # Uncached version of setter_methods, to be overridden by plugins
       # that want to modify the methods used.
       def get_setter_methods
@@ -1076,7 +1102,7 @@ module Sequel
         @modified = true
         initialize_set(values)
         _clear_changed_columns(:initialize)
-        yield self if block_given?
+        yield self if defined?(yield)
       end
 
       # Returns value of the column's attribute.
@@ -1116,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
@@ -1135,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,
@@ -1207,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
@@ -1243,12 +1269,12 @@ module Sequel
       # Once an object is frozen, you cannot modify it's values, changed_columns,
       # errors, or dataset.
       def freeze
-        values.freeze
-        _changed_columns.freeze
         unless errors.frozen?
           validate
           errors.freeze
         end
+        values.freeze
+        _changed_columns.freeze
         this if !new? && model.primary_key
         super
       end
@@ -1309,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?
@@ -1613,11 +1639,9 @@ module Sequel
       #   artist.set(name: 'Invalid').valid? # => false
       #   artist.errors.full_messages # => ['name cannot be Invalid']
       def valid?(opts = OPTS)
-        begin
-          _valid?(opts)
-        rescue HookFailed
-          false
-        end
+        _valid?(opts)
+      rescue HookFailed
+        false
       end
 
       private

data/lib/sequel/model/dataset_module.rb

@@ -8,6 +8,9 @@ module Sequel
     # automatically creates class methods for public dataset
     # methods.
     class DatasetModule < Dataset::DatasetModule
+      # The model class related to this dataset module.
+      attr_reader :model
+
       # Store the model related to this dataset module.
       def initialize(model)
         @model = model

data/lib/sequel/model/errors.rb

@@ -38,7 +38,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(' and ')} #{e}")}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : full_message(att, e))}
           m
         end
       end
@@ -53,6 +53,15 @@ module Sequel
           v
         end
       end
+
+      private
+
+      # Create full error message to use for the given attribute (or array of attributes)
+      # and error message. This can be overridden for easier internalization.
+      def full_message(att, error_msg)
+        att = att.join(' and ') if att.is_a?(Array)
+        "#{att} #{error_msg}"
+      end
     end
   end
 end

data/lib/sequel/model/inflections.rb

@@ -4,7 +4,7 @@ module Sequel
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
 

data/lib/sequel/model/plugins.rb

@@ -31,7 +31,9 @@ module Sequel
     def self.def_dataset_methods(mod, meths)
       Array(meths).each do |meth|
         mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        # :nocov:
         mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
     end
 
@@ -120,6 +122,7 @@ module Sequel
 
       model.send(:define_method, meth, &block)
       model.send(:private, meth)
+      model.send(:alias_method, meth, meth)
       call_meth
     end
 
@@ -141,6 +144,8 @@ module Sequel
           keyword = :required
         when :key, :keyrest
           keyword ||= true
+        else
+          raise Error, "invalid arg_type passed to _define_sequel_method_arg_numbers: #{arg_type}"
         end
       end
       arity = callable.arity

data/lib/sequel/plugins/association_proxies.rb

@@ -99,7 +99,9 @@ module Sequel
           end
           v.public_send(meth, *args, &block)
         end
+        # :nocov:
         ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
 
       module ClassMethods

data/lib/sequel/plugins/async_thread_pool.rb

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+
+module Sequel
+  extension 'async_thread_pool'
+
+  module Plugins
+    # The async_thread_pool plugin makes it slightly easier to use the async_thread_pool
+    # Database extension with models.  It makes Model.async return an async dataset for the
+    # model, and support async behavior for #destroy, #with_pk, and #with_pk! for model
+    # datasets:
+    #
+    #   # Will load the artist with primary key 1 asynchronously
+    #   artist = Artist.async.with_pk(1)
+    #
+    # You must load the async_thread_pool Database extension into the Database object the
+    # model class uses in order for async behavior to work.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass datasets support support async class methods and additional
+    #   # async dataset methods
+    #   Sequel::Model.plugin :async_thread_pool
+    #
+    #   # Make the Album class support async class method and additional async dataset methods
+    #   Album.plugin :async_thread_pool
+    module AsyncThreadPool
+      module ClassMethods
+        Plugins.def_dataset_methods(self, :async)
+      end
+
+      module DatasetMethods
+        [:destroy, :with_pk, :with_pk!].each do |meth|
+          ::Sequel::Database::AsyncThreadPool::DatasetMethods.define_async_method(self, meth)
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/auto_restrict_eager_graph.rb

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_restrict_eager_graph plugin will automatically disallow the use
+    # of eager_graph for associations that have associated blocks but no :graph_*
+    # association options.  The reason for this is the block will have an effect
+    # during regular and eager loading, but not loading via eager_graph, and it
+    # is likely that whatever the block is doing should have an equivalent done
+    # when eager_graphing.  Most likely, not including a :graph_* option was either
+    # an oversight (and one should be added), or use with eager_graph was never
+    # intended (and usage should be forbidden).  Disallowing eager_graph in this
+    # case prevents likely unexpected behavior during eager_graph.
+    #
+    # As an example of this, consider the following code:
+    #
+    #   Album.one_to_many :popular_tracks, class: :Track do |ds|
+    #     ds = ds.where(popular: true)
+    #   end  
+    #
+    #   Album.eager(:popular_tracks).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM tracks WHERE ((popular IS TRUE) AND (album_id IN (...)))
+    #
+    #   # Notice that no condition for tracks.popular is added.
+    #   Album.eager_graph(:popular_tracks).all
+    #   # SELECT ... FROM albums LEFT JOIN tracks ON (tracks.album_id = albums.id)
+    #   
+    # With the auto_restrict_eager_graph plugin, the eager_graph call above will
+    # raise an error, alerting you to the fact that you either should not be
+    # using eager_graph with the association, or that you should be adding an
+    # appropriate :graph_* option, such as:
+    #
+    #   Album.one_to_many :popular_tracks, class: :Track, graph_conditions: {popular: true} do |ds|
+    #     ds = ds.where(popular: true)
+    #   end  
+    #
+    # Usage:
+    #
+    #   # Automatically restrict eager_graph for associations if appropriate for all
+    #   # model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_restrict_eager_graph
+    #
+    #   # Automatically restrict eager_graph for associations in Album class
+    #   Album.plugin :auto_restrict_eager_graph
+    module AutoRestrictEagerGraph
+      module ClassMethods
+        # When defining an association, if a block is given for the association, but
+        # a :graph_* option is not used, disallow the use of eager_graph.
+        def associate(type, name, opts = OPTS, &block)
+          opts = super
+
+          if opts[:block] && !opts.has_key?(:allow_eager_graph) && !opts[:orig_opts].any?{|k,| /\Agraph_/ =~ k}
+            opts[:allow_eager_graph] = false
+          end
+
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/auto_validations.rb

@@ -9,12 +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.
+    # 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.
     #
     # This plugin uses the validation_helpers plugin underneath to implement the
     # validations.  It does not allow for any per-column validation message
@@ -48,9 +52,14 @@ 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
+    # have an error associated with them, you can use the skip_invalid option:
+    #
+    #   Model.plugin :auto_validations, skip_invalid: true
+    #
     # Usage:
     #
     #   # Make all model subclass use auto validations (called before loading subclasses)
@@ -64,25 +73,35 @@ module Sequel
       MAX_LENGTH_OPTIONS = {:from=>:values, :allow_nil=>true}.freeze
       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)
         model.instance_exec do
           plugin :validation_helpers
           @auto_validate_presence = false
+          @auto_validate_no_null_byte_columns = []
           @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 = {
-              :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
 
@@ -95,16 +114,26 @@ module Sequel
           end
 
           h = @auto_validate_options.dup
-          [:not_null, :explicit_not_null, :max_length, :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
           end
+
+          if opts[:skip_invalid]
+            [:not_null, :explicit_not_null, :no_null_byte, :max_length, :schema_types].each do |type|
+              h[type] = h[type].merge(:skip_invalid=>true).freeze
+            end
+          end
+
           @auto_validate_options = h.freeze
         end
       end
 
       module ClassMethods
+        # The columns with automatic no_null_byte validations
+        attr_reader :auto_validate_no_null_byte_columns
+
         # The columns with automatic not_null validations
         attr_reader :auto_validate_not_null_columns
 
@@ -115,13 +144,31 @@ 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
 
         # Inherited options
         attr_reader :auto_validate_options
 
-        Plugins.inherited_instance_variables(self, :@auto_validate_presence=>nil, :@auto_validate_types=>nil, :@auto_validate_not_null_columns=>:dup, :@auto_validate_explicit_not_null_columns=>:dup, :@auto_validate_max_length_columns=>:dup, :@auto_validate_unique_columns=>:dup, :@auto_validate_options => :dup)
+        Plugins.inherited_instance_variables(self,
+          :@auto_validate_presence=>nil,
+          :@auto_validate_types=>nil,
+          :@auto_validate_no_null_byte_columns=>:dup,
+          :@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)
 
         # Whether to use a presence validation for not null columns
@@ -136,20 +183,27 @@ module Sequel
 
         # Freeze auto_validation settings when freezing model class.
         def freeze
+          @auto_validate_no_null_byte_columns.freeze
           @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).
+        # Skip automatic validations for the given validation type
+        # (: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, :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
@@ -169,6 +223,9 @@ 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)}
             db.indexes(table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns].length == 1 ? idx[:columns].first : idx[:columns]}
@@ -195,6 +252,9 @@ module Sequel
           return if skip.include?(:all)
           opts = model.auto_validate_options
 
+          unless skip.include?(:no_null_byte) || (no_null_byte_columns = model.auto_validate_no_null_byte_columns).empty?
+            validates_no_null_byte(no_null_byte_columns, opts[:no_null_byte])
+          end
 
           unless skip.include?(:not_null)
             not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null
@@ -214,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)

data/lib/sequel/plugins/auto_validations_constraint_validations_presence_message.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_validations_constraint_validations_presence_message plugin provides
+    # integration for the auto_validations and constraint_validations plugins in
+    # the following situation:
+    #
+    # * A column has a NOT NULL constraint in the database
+    # * A constraint validation for presence exists on the column, with a :message
+    #   option to set a column-specific message, and with the :allow_nil option set
+    #   to true because the CHECK constraint doesn't need to check for NULL values
+    #   as the column itself is NOT NULL
+    # 
+    # In this case, by default the validation error message on the column will
+    # use the more specific constraint validation error message if the column
+    # has a non-NULL empty value, but will use the default auto_validations
+    # message if the column has a NULL value.  With this plugin, the column-specific
+    # constraint validation error message will be used in both cases.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use this auto_validations/constraint_validations
+    #   # integration (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_validations_constraint_validations_presence_message
+    #
+    #   # Make the Album class use this auto_validations/constraint_validations integration
+    #   Album.plugin :auto_validations_constraint_validations_presence_message
+    module AutoValidationsConstraintValidationsPresenceMessage
+      def self.apply(model)
+        model.plugin :auto_validations
+        model.plugin :constraint_validations
+      end
+
+      def self.configure(model, opts=OPTS)
+        model.send(:_adjust_auto_validations_constraint_validations_presence_message)
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :_adjust_auto_validations_constraint_validations_presence_message)
+
+        private
+
+        def _adjust_auto_validations_constraint_validations_presence_message
+          if @dataset &&
+             !@auto_validate_options[:not_null][:message] &&
+             !@auto_validate_options[:explicit_not_null][:message]
+
+            @constraint_validations.each do |array|
+              meth, column, opts = array
+
+              if meth == :validates_presence &&
+                 opts &&
+                 opts[:message] &&
+                 opts[:allow_nil] &&
+                 (@auto_validate_not_null_columns.include?(column) || @auto_validate_explicit_not_null_columns.include?(column))
+
+                @auto_validate_not_null_columns.delete(column)
+                @auto_validate_explicit_not_null_columns.delete(column)
+                array[2] = array[2].merge(:allow_nil=>false)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/class_table_inheritance.rb

@@ -104,7 +104,7 @@ module Sequel
     # should reference the subquery alias (and qualified identifiers should not be needed
     # unless joining to another table):
     #
-    #   a = Executive.where(:id=>1).first # works
+    #   a = Executive.where(id: 1).first # works
     #   a = Executive.where{{employees[:id]=>1}}.first # works
     #   a = Executive.where{{executives[:id]=>1}}.first # doesn't work
     #
@@ -115,7 +115,7 @@ module Sequel
     #
     #   pks = Executive.where{num_staff < 10}.select_map(:id)
     #   Executive.cti_tables.reverse_each do |table|
-    #     DB.from(table).where(:id=>pks).delete
+    #     DB.from(table).where(id: pks).delete
     #   end
     #
     # = Usage