sequel 5.93.0 → 5.95.0

data/lib/sequel/database/misc.rb

@@ -36,13 +36,13 @@ module Sequel
 
     # Register a hook that will be run when a new Database is instantiated. It is
     # called with the new database handle.
-    def self.after_initialize(&block)
-      raise Error, "must provide block to after_initialize" unless block
+    def self.after_initialize
+      raise Error, "must provide block to after_initialize" unless defined?(yield)
       Sequel.synchronize do
         previous = @initialize_hook
         @initialize_hook = proc do |db|
           previous.call(db)
-          block.call(db)
+          yield(db)
         end
       end
     end

data/lib/sequel/database/query.rb

@@ -269,7 +269,7 @@ module Sequel
     def column_schema_to_ruby_default(default, type)
       return default unless default.is_a?(String)
       if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
-        if /now|today|CURRENT|getdate|\ADate\(\)\z/i.match(default)
+        if /now|today|CURRENT|getdate|\ADate\(\)\z/i =~ default
           if type == :date
             return Sequel::CURRENT_DATE
           else

data/lib/sequel/database/schema_generator.rb

@@ -118,6 +118,11 @@ module Sequel
       #         that this column references.  Unnecessary if this column
       #         references the primary key of the associated table, except if you are
       #         using MySQL.
+      # :not_null :: Similar to setting <tt>null: false</tt>, but you can provide a hash value
+      #              to specify options for the NOT NULL constraint on PostgreSQL 18+:
+      #              :name :: The name of the NOT NULL constraint
+      #              :no_inherit :: Set NO INHERIT on the constraint, so it will not propogate to
+      #                             child tables.
       # :null :: Mark the column as allowing NULL values (if true),
       #          or not allowing NULL values (if false).  The default is to allow NULL values.
       # :on_delete :: Specify the behavior of this column when being deleted
@@ -126,17 +131,27 @@ module Sequel
       #               (:restrict, :cascade, :set_null, :set_default, :no_action).
       # :primary_key :: Make the column as a single primary key column.  This should not
       #                 be used if you want a single autoincrementing primary key column
-      #                 (use the primary_key method in that case).
-      # :primary_key_constraint_name :: The name to give the primary key constraint
-      # :primary_key_deferrable :: Similar to :deferrable, but for the primary key constraint
-      #                            if :primary_key is used.
+      #                 (use the primary_key method in that case).  Can be a hash to provide
+      #                 options for the constraint:
+      #                 :name :: The name to give the primary key constraint.
+      #                 :deferrable :: Sets whether the primary key constraint is deferrable.
+      #                 :include :: Include additional columns in the underlying index, to
+      #                             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :primary_key_constraint_name :: Older option to name primary key constraint.
+      # :primary_key_deferrable :: Older option to set primary key constraint as deferrable.
       # :type :: Overrides the type given as the argument.  Generally not used by column
       #          itself, but can be passed as an option to other methods that call column.
       # :unique :: Mark the column as unique, generally has the same effect as
-      #            creating a unique index on the column.
-      # :unique_constraint_name :: The name to give the unique key constraint
-      # :unique_deferrable :: Similar to :deferrable, but for the unique constraint if :unique
-      #                       is used.
+      #            creating a unique index on the column. Can be a hash to provide options for
+      #            the constraint:
+      #            :name :: The name to give the unique constraint.
+      #            :deferrable :: Sets whether the unique constraint is deferrable.
+      #            :include :: Include additional columns in the underlying index, to
+      #                        allow for index-only scans in more cases (PostgreSQL 11+).
+      #            :nulls_not_distinct :: Use NULLS NOT DISTINCT to setup a constraint where NULL
+      #                                   entries are considered distinct (PostgreSQL 15+)
+      # :unique_constraint_name :: Older option to name unique constraint.
+      # :unique_deferrable :: Older option to set unique constraint as deferrable.
       #
       # PostgreSQL specific options:
       #
@@ -178,6 +193,9 @@ module Sequel
       # :deferrable :: Whether the CHECK constraint should be marked DEFERRABLE.
       #
       # PostgreSQL specific options:
+      # :no_inherit :: Set NO INHERIT on the constraint, so it will not propogate to
+      #                child tables.
+      # :not_enforced :: Whether the CHECK constraint should be marked NOT ENFORCED.
       # :not_valid :: Whether the CHECK constraint should be marked NOT VALID.
       def constraint(name, *args, &block)
         opts = name.is_a?(Hash) ? name : {:name=>name}
@@ -197,9 +215,21 @@ module Sequel
       #
       # :foreign_key_constraint_name :: The name to give the foreign key constraint
       #
+      # PostgreSQL specific options:
+      #
+      # :not_enforced :: Whether the foreign key constraint should be marked NOT ENFORCED.
+      #
       # If you want a foreign key constraint without adding a column (usually because it is a
-      # composite foreign key), you can provide an array of columns as the first argument, and
-      # you can provide the :name option to name the constraint:
+      # composite foreign key), you can provide an array of columns as the first argument.
+      # This changes the method to accept constraint options instead of column options.
+      # You can provide the :name option to name the constraint.
+      #
+      # PostgreSQL specific options:
+      #
+      # :not_enforced :: Whether the foreign key constraint should be marked NOT ENFORCED.
+      # :period :: Use PERIOD to setup a constraint where the final column is a range
+      #            or multirange column, and the range or multirange is covered by
+      #            existing ranges in the referenced table (which can be in separate rows).
       #
       #   foreign_key([:artist_name, :artist_location], :artists, name: :artist_fk)
       #   # ADD CONSTRAINT artist_fk FOREIGN KEY (artist_name, artist_location) REFERENCES artists
@@ -303,6 +333,13 @@ module Sequel
       # :keep_order :: For non-composite primary keys, respects the existing order of
       #                columns, overriding the default behavior of making the primary
       #                key the first column.
+      #
+      # PostgreSQL specific options:
+      #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite primary keys only).
       # 
       # Examples:
       #   primary_key(:id)
@@ -346,6 +383,15 @@ module Sequel
       #
       # Supports the same :deferrable option as #column. The :name option can be used
       # to name the constraint.
+      #
+      # PostgreSQL specific options:
+      #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :nulls_not_distinct :: Use NULLS NOT DISTINCT to setup a constraint where NULL
+      #                        entries are considered distinct (PostgreSQL 15+)
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite unique only).
       def unique(columns, opts = OPTS)
         constraints << {:type => :unique, :columns => Array(columns)}.merge!(opts)
         nil
@@ -433,7 +479,13 @@ module Sequel
       #
       # PostgreSQL specific options:
       #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
+      # :nulls_not_distinct :: Use NULLS NOT DISTINCT to setup a constraint where NULL
+      #                        entries are considered distinct (PostgreSQL 15+)
       # :using_index :: Use the USING INDEX clause to specify an existing unique index
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite unique constraints only).
       def add_unique_constraint(columns, opts = OPTS)
         @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge!(opts)
         nil
@@ -490,7 +542,11 @@ module Sequel
       #
       # PostgreSQL specific options:
       #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
       # :using_index :: Use the USING INDEX clause to specify an existing unique index
+      # :without_overlaps :: Use WITHOUT OVERLAPS clause to specify an exclusion constraint
+      #                      on the final column (PostgreSQL 18+, composite primary keys only).
       def add_primary_key(name, opts = OPTS)
         return add_composite_primary_key(name, opts) if name.is_a?(Array)
         opts = @db.serial_primary_key_options.merge(opts)

data/lib/sequel/database/schema_methods.rb

@@ -592,7 +592,12 @@ module Sequel
     
     # Add null/not null SQL fragment to column creation SQL.
     def column_definition_null_sql(sql, column)
-      null = column.fetch(:null, column[:allow_null])
+      null = if column[:not_null]
+        false
+      else
+        column.fetch(:null, column[:allow_null])
+      end
+
       if null.nil? && !can_add_primary_key_constraint_on_nullable_columns? && column[:primary_key]
         null = false
       end
@@ -605,36 +610,71 @@ module Sequel
       end
     end
 
-    # Add primary key SQL fragment to column creation SQL.
+    # Add primary key SQL fragment to column creation SQL if column is a primary key.
     def column_definition_primary_key_sql(sql, column)
-      if column[:primary_key]
-        if name = column[:primary_key_constraint_name]
-          sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << " " << primary_key_constraint_sql_fragment(column)
-        constraint_deferrable_sql_append(sql, column[:primary_key_deferrable])
-      end
+      column_definition_add_primary_key_sql(sql, column) if column[:primary_key]
+    end
+
+    # Add primary key SQL fragment to column creation SQL (column should be a primary key).
+    def column_definition_add_primary_key_sql(sql, column)
+      constraint = column_definition_constraint_hash(column, :primary_key)
+      append_named_constraint_prefix_sql(sql, constraint[:name])
+      column_definition_append_primary_key_sql(sql, constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
+    end
+
+    def column_definition_append_primary_key_sql(sql, constraint)
+      sql << " " << primary_key_constraint_sql_fragment(constraint)
     end
     
-    # Add foreign key reference SQL fragment to column creation SQL.
+    # Add foreign key reference SQL fragment to column creation SQL if column is a foreign key.
     def column_definition_references_sql(sql, column)
-      if column[:table]
-        if name = column[:foreign_key_constraint_name]
-         sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << column_references_column_constraint_sql(column)
-      end
+      column_definition_add_references_sql(sql, column) if column[:table]
+    end
+
+    # Add foreign key reference SQL fragment to column creation SQL (column should be a foreign key).
+    def column_definition_add_references_sql(sql, column)
+      append_named_constraint_prefix_sql(sql, column[:foreign_key_constraint_name])
+      sql << column_references_column_constraint_sql(column)
     end
     
-    # Add unique constraint SQL fragment to column creation SQL.
+    # Add unique constraint SQL fragment to column creation SQL if column has a unique constraint.
     def column_definition_unique_sql(sql, column)
-      if column[:unique]
-        if name = column[:unique_constraint_name]
-          sql << " CONSTRAINT #{quote_identifier(name)}"
-        end
-        sql << ' ' << unique_constraint_sql_fragment(column)
-        constraint_deferrable_sql_append(sql, column[:unique_deferrable])
+      column_definition_add_unique_sql(sql, column) if column[:unique]
+    end
+
+    # Add unique constraint SQL fragment to column creation SQL (column should have unique constraint).
+    def column_definition_add_unique_sql(sql, column)
+      constraint = column_definition_constraint_hash(column, :unique)
+      append_named_constraint_prefix_sql(sql, constraint[:name])
+      column_definition_append_unique_sql(sql, constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
+    end
+
+    def column_definition_append_unique_sql(sql, constraint)
+      sql << ' ' << unique_constraint_sql_fragment(constraint)
+    end
+
+    # Add the name of the constraint to the column creation SQL.
+    def append_named_constraint_prefix_sql(sql, name)
+      sql << " CONSTRAINT #{quote_identifier(name)}" if name
+    end
+
+    # Return a hash of constraint options for the primary key or column
+    # unique constraint.
+    def column_definition_constraint_hash(column, prefix)
+      constraint = column[prefix]
+      constraint = constraint.is_a?(Hash) ? constraint.dup : {}
+
+      if name = column[:"#{prefix}_constraint_name"]
+        constraint[:name] = name
+      end
+
+      if column.has_key?(:"#{prefix}_deferrable")
+        constraint[:deferrable] = column[:"#{prefix}_deferrable"]
       end
+
+      constraint
     end
     
     # SQL for all given columns, used inside a CREATE TABLE block.
@@ -651,12 +691,16 @@ module Sequel
     def column_references_sql(column)
       sql = String.new
       sql << " REFERENCES #{quote_schema_table(column[:table])}"
-      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(', ')})" if column[:key]
+      column_references_append_key_sql(sql, column) if column[:key]
       sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
       sql << " ON UPDATE #{on_update_clause(column[:on_update])}" if column[:on_update]
       constraint_deferrable_sql_append(sql, column[:deferrable])
       sql
     end
+
+    def column_references_append_key_sql(sql, column)
+      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(', ')})"
+    end
   
     # SQL fragment for table foreign key references (table constraints)
     def column_references_table_constraint_sql(constraint)
@@ -677,7 +721,7 @@ module Sequel
         check = constraint[:check]
         check = check.first if check.is_a?(Array) && check.length == 1
         check = filter_expr(check)
-        check = "(#{check})" unless check[0..0] == '(' && check[-1..-1] == ')'
+        check = "(#{check})" unless check.start_with?('(') && check.end_with?(')')
         sql << "CHECK #{check}"
       when :primary_key
         sql << "#{primary_key_constraint_sql_fragment(constraint)} #{literal(constraint[:columns])}"
@@ -733,17 +777,24 @@ module Sequel
     def create_table_sql(name, generator, options)
       unless supports_named_column_constraints?
         # Split column constraints into table constraints if they have a name
+        fk_opt_keys = [:key, :on_delete, :on_update, :deferrable]
         generator.columns.each do |c|
           if (constraint_name = c.delete(:foreign_key_constraint_name)) && (table = c.delete(:table))
             opts = {}
             opts[:name] = constraint_name
-            [:key, :on_delete, :on_update, :deferrable].each{|k| opts[k] = c[k]}
+            fk_opt_keys.each{|k| opts[k] = c[k]}
             generator.foreign_key([c[:name]], table, opts)
           end
-          if (constraint_name = c.delete(:unique_constraint_name)) && c.delete(:unique)
+
+          if c[:unique].is_a?(Hash) && c[:unique][:name]
+            generator.unique(c[:name], c.delete(:unique))
+          elsif (constraint_name = c.delete(:unique_constraint_name)) && c.delete(:unique)
             generator.unique(c[:name], :name=>constraint_name)
           end
-          if (constraint_name = c.delete(:primary_key_constraint_name)) && c.delete(:primary_key)
+
+          if c[:primary_key].is_a?(Hash) && c[:primary_key][:name]
+            generator.primary_key([c[:name]], c.delete(:primary_key))
+          elsif (constraint_name = c.delete(:primary_key_constraint_name)) && c.delete(:primary_key)
             generator.primary_key([c[:name]], :name=>constraint_name)
           end
         end

data/lib/sequel/dataset/query.rb

@@ -231,8 +231,7 @@ module Sequel
     #
     #   DB[:table].for_update # SELECT * FROM table FOR UPDATE
     def for_update
-       return self if opts[:lock] == :update
-      cached_dataset(:_for_update_ds){lock_style(:update)}
+      cached_lock_style_dataset(:_for_update_ds, :update)
     end
 
     # Returns a copy of the dataset with the source changed. If no
@@ -1462,6 +1461,15 @@ module Sequel
       end
     end
 
+    # Internals of for_update and adapter-specific lock methods.
+    # Returns receiver if it already uses this lock style, and a cached
+    # dataset using the given key otherwise. The key could be derived from
+    # the style, but doing so would require allocation, so pass it in as
+    # an argument.
+    def cached_lock_style_dataset(key, style)
+      opts[:lock] == style ? self : cached_dataset(key){lock_style(style)}
+    end
+
     # The default :qualify option to use for join tables if one is not specified.
     def default_join_table_qualification
       :symbol

data/lib/sequel/dataset/sql.rb

@@ -1339,7 +1339,7 @@ module Sequel
     # SQL fragment specifying a JOIN type, converts underscores to
     # spaces and upcases.
     def join_type_sql(join_type)
-      "#{join_type.to_s.gsub('_', ' ').upcase} JOIN"
+      "#{join_type.to_s.tr('_', ' ').upcase} JOIN"
     end
 
     # Append USING clause for JOIN USING

data/lib/sequel/extensions/async_thread_pool.rb

@@ -357,7 +357,7 @@ module Sequel
           define_singleton_method(:async_job_class){proxy_klass}
 
           queue = @async_thread_queue = Queue.new
-          pool = @async_thread_pool = num_async_threads.times.map{JobProcessor.new(queue)}
+          pool = @async_thread_pool = Array.new(num_async_threads){JobProcessor.new(queue)}
           ObjectSpace.define_finalizer(db, JobProcessor.create_finalizer(queue, pool))
 
           extend_datasets(DatasetMethods)

data/lib/sequel/extensions/caller_logging.rb

@@ -60,9 +60,7 @@ module Sequel
     def external_caller_for_log
       ignore = caller_logging_ignore
       c = caller.find do |line|
-        !(line.start_with?(SEQUEL_LIB_PATH) ||
-          line.start_with?(RUBY_STDLIB) ||
-          line.start_with?(INTERNAL) ||
+        !(line.start_with?(SEQUEL_LIB_PATH, RUBY_STDLIB, INTERNAL) ||
           (ignore && line =~ ignore))
       end
 

data/lib/sequel/extensions/eval_inspect.rb

@@ -66,7 +66,7 @@ module Sequel
         # in the order they were defined.
         klass = self.class
         args = inspect_args.map do |arg|
-          if arg.is_a?(String) && arg =~ /\A\*/
+          if arg.is_a?(String) && arg.start_with?('*')
             # Special case string arguments starting with *, indicating that
             # they should return an array to be splatted as the remaining arguments.
             # Allow calling private methods to get inspect output.

data/lib/sequel/extensions/inflector.rb

@@ -159,7 +159,7 @@ class String
   # Example
   #   "puni_puni".dasherize #=> "puni-puni"
   def dasherize
-    gsub('_', '-')
+    tr('_', '-')
   end
 
   # Removes the module part from the expression in the string
@@ -189,7 +189,7 @@ class String
   #   "employee_salary" #=> "Employee salary"
   #   "author_id" #=> "Author"
   def humanize
-    gsub(/_id$/, "").gsub('_', " ").capitalize
+    gsub(/_id$/, "").tr('_', " ").capitalize
   end
 
   # Returns the plural form of the word in the string.

data/lib/sequel/extensions/migration.rb

@@ -845,7 +845,7 @@ module Sequel
         begin
           db.create_table(table){String c, :primary_key=>true}
         rescue Sequel::DatabaseError => e
-          if db.database_type == :mysql && e.message =~ /max key length/
+          if db.database_type == :mysql && e.message.include?('max key length')
             # Handle case where MySQL is used with utf8mb4 charset default, which
             # only allows a maximum length of about 190 characters for string
             # primary keys due to InnoDB limitations.

data/lib/sequel/extensions/pg_hstore.rb

@@ -136,7 +136,7 @@ module Sequel
       module DatabaseMethods
         def self.extended(db)
           db.instance_exec do
-            add_named_conversion_proc(:hstore, &HStore.method(:parse))
+            add_named_conversion_proc(:hstore){|v| HStore.parse(v)}
             @schema_type_classes[:hstore] = HStore
           end
         end

data/lib/sequel/extensions/provenance.rb

@@ -97,9 +97,7 @@ module Sequel
       def provenance_source
         ignore = db.opts[:provenance_caller_ignore]
         caller.find do |line|
-          !(line.start_with?(SEQUEL_LIB_PATH) ||
-            line.start_with?(RUBY_STDLIB) ||
-            line.start_with?(INTERNAL) ||
+          !(line.start_with?(SEQUEL_LIB_PATH, RUBY_STDLIB, INTERNAL) ||
             (ignore && line =~ ignore))
         end
       end

data/lib/sequel/extensions/schema_dumper.rb

@@ -221,7 +221,7 @@ END_MIG
       else
         col_opts = if options[:same_db]
           h = {:type=>schema[:db_type]}
-          if database_type == :mysql && h[:type] =~ /\Atimestamp/
+          if database_type == :mysql && h[:type].start_with?("timestamp")
             h[:null] = true
           end
           if database_type == :mssql && schema[:max_length]

data/lib/sequel/plugins/class_table_inheritance_constraint_validations.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'constraint_validations'
+require_relative 'class_table_inheritance'
+
+module Sequel
+  module Plugins
+    # = Overview
+    #
+    # The class_table_inheritance_constraint_validations plugin extends the
+    # constraint_validations plugin to work correctly with the
+    # class_table_inheritance plugin. It ensures that constraint_validations
+    # are loaded from all tables in the class table inheritance hierarchy,
+    # not just the base table.
+    #
+    # = Example
+    #
+    # For example, with this hierarchy, where each model has its own table with
+    # constraint validations:
+    #
+    #       Employee
+    #      /        \
+    #   Staff     Manager
+    #                |
+    #            Executive
+    #
+    #   # Loads constraint_validations from the employees table
+    #   class Employee < Sequel::Model
+    #     plugin :class_table_inheritance
+    #     plugin :constraint_validations
+    #     plugin :class_table_inheritance_constraint_validations
+    #   end
+    #
+    #   # Loads constraint_validations from managers and employees tables
+    #   class Manager < Employee
+    #   end
+    #
+    #   # Loads constraint_validations from executives, managers, and
+    #   # employees tables
+    #   class Executive < Manager
+    #   end
+    #
+    #   # Loads constraint_validations from staff and employees tables
+    #   class Staff < Employee
+    #   end
+    module ClassTableInheritanceConstraintValidations
+      def self.apply(model)
+        unless ConstraintValidations::InstanceMethods > model && ClassTableInheritance::InstanceMethods > model
+          raise Error, "must load the constraint_validations and class_table_inheritance plugins into #{model} before loading class_table_inheritance_constraint_validations plugin"
+        end
+      end
+
+      module ClassMethods
+        private
+
+        def inherited(subclass)
+          super
+
+          # constraint_validations will parse_constraint_validations in the
+          # classes after_set_dataset hook. That runs before cti_tables are
+          # updated for subclasses in class_table_inheritance's inherited
+          # so re-parsing them here.
+          subclass.send(:parse_constraint_validations)
+        end
+
+        def parse_constraint_validations_dataset
+          reflections = {}
+          allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+          hash = Sequel.synchronize{db.constraint_validations}
+          cv = []
+          ds = @dataset.with_quote_identifiers(false)
+          cti_tables.each do |table_name|
+            table_name = ds.literal(table_name)
+            cv += (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
+          end
+          @constraint_validations = cv
+          @constraint_validation_reflections = reflections
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/constraint_validations.rb

@@ -113,7 +113,7 @@ module Sequel
         def parse_constraint_validations
           db.extension(:_model_constraint_validations)
 
-          unless hash = Sequel.synchronize{db.constraint_validations}
+          unless Sequel.synchronize{db.constraint_validations}
             hash = {}
             db.from(constraint_validations_table).each do |r|
               (hash[r[:table]] ||= []) << r
@@ -121,14 +121,7 @@ module Sequel
             Sequel.synchronize{db.constraint_validations = hash}
           end
 
-          if @dataset
-            ds = @dataset.with_quote_identifiers(false)
-            table_name = ds.literal(ds.first_source_table)
-            reflections = {}
-            allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
-            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
-            @constraint_validation_reflections = reflections
-          end
+          parse_constraint_validations_dataset if @dataset
         end
 
         # Given a specific database constraint validation metadata row hash, transform
@@ -164,7 +157,7 @@ module Sequel
             arg = constraint_validation_int_range(arg)
             type = :includes
           when *OPERATOR_MAP.keys
-            arg = arg.to_i if type.to_s =~ /\Aint_/
+            arg = arg.to_i if type.to_s.start_with?('int_')
             operator = OPERATOR_MAP[type]
             type = :operator
           end
@@ -236,6 +229,18 @@ module Sequel
             Regexp.new(arg)
           end
         end
+
+        # If this model has associated dataset, use the model's table name
+        # to get the validations for just this model.
+        def parse_constraint_validations_dataset
+          ds = @dataset.with_quote_identifiers(false)
+          table_name = ds.literal(ds.first_source_table)
+          reflections = {}
+          allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+          hash = Sequel.synchronize{db.constraint_validations}
+          @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
+          @constraint_validation_reflections = reflections
+        end
       end
 
       module InstanceMethods

data/lib/sequel/plugins/json_serializer.rb

@@ -370,9 +370,9 @@ module Sequel
         end
 
         # Convert the receiver to a JSON data structure using the given arguments.
-        def to_json_data(*args, &block)
-          if block
-            to_json(*args){|x| return block.call(x)}
+        def to_json_data(*args)
+          if defined?(yield)
+            to_json(*args){|x| return yield(x)}
           else
             to_json(*args){|x| return x}
           end

data/lib/sequel/plugins/unused_associations.rb

@@ -347,6 +347,8 @@ module Sequel
           coverage_data = options[:coverage_data] || Sequel.parse_json(File.binread(@unused_associations_coverage_file))
 
           unused_associations_data = {}
+          to_many_modification_methods = [:adder, :remover, :clearer]
+          modification_methods = [:setter, :adder, :remover, :clearer]
 
           ([self] + descendants).each do |sc|
             next unless cov_data = coverage_data[sc.name]
@@ -383,8 +385,8 @@ module Sequel
               if !info[:used]
                 (unused_associations_data[sc.name] ||= {})[assoc.to_s] = 'unused'
               elsif unused = info[:unused]
-                if unused.include?(:setter) || [:adder, :remover, :clearer].all?{|k| unused.include?(k)}
-                  [:setter, :adder, :remover, :clearer].each do |k|
+                if unused.include?(:setter) || to_many_modification_methods.all?{|k| unused.include?(k)}
+                  modification_methods.each do |k|
                     unused.delete(k)
                   end
                   unused << :read_only

data/lib/sequel/plugins/validation_class_methods.rb

@@ -208,7 +208,7 @@ module Sequel
               next if an && Array(v).all?(&:nil?)
               next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
-              block.call(o,a,v)
+              yield(o, a, v)
             end
           else
             block

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