sequel 5.94.0 → 5.95.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05c58f7009f56c4891e863d95ccd90eeb7acdc03f192979ff0d4a203fa1924d4
-  data.tar.gz: 957d465eebddd41b7de48475af26b04f4ae6fb387662257b97b9bdbc682eb197
+  metadata.gz: 7a008ffa4ce90081d7259c785ca68f6f3e3209d789ce6016da8040ea89acca49
+  data.tar.gz: a9f7af4d4214ca4dd82d4909e8aa2c79c96821245f39cc34278df788ae319cb6
 SHA512:
-  metadata.gz: eb72cd090c58b8246b4a679082f9426f9aecf2d4815dffa2d96fe3be5a15b3e41b9ae7dd17effee49bfab82ac54c11d5d7d6aa67ff2a8aa54040145f5c72a3b0
-  data.tar.gz: 031fcb089d79550e485be488ec6d4b0d84024e4f686ebe953a08189c5b9d6e490c2351246b4258d8b78e9efafd013db61738f19e40a04afbb9fb1ec1796e5e6a
+  metadata.gz: 9aa9d1fb1cb8a0a323331b2cdccc48b51b5b9f38289be280f693e0b998747d6c7a5e204c29c13cb89bd50caeb5bde604527eb8966249edfe3ab0866bb039bdf2
+  data.tar.gz: 894997717d624f602d9dbfaa554ac03270a50a69f5da6982fd687101af95e94c02a3c82b0fbe9e5ec8a5c4d39265fb4e18d9b9f706be216fccc7c45cd72a00ce

data/lib/sequel/adapters/shared/postgres.rb

@@ -124,6 +124,8 @@ module Sequel
       #
       # Options supported:
       #
+      # :include :: Include additional columns in the underlying index, to
+      #             allow for index-only scans in more cases (PostgreSQL 11+).
       # :name :: Name the constraint with the given name (useful if you may
       #          need to drop the constraint later)
       # :using :: Override the index_method for the exclusion constraint (defaults to gist).
@@ -1254,6 +1256,22 @@ module Sequel
         end
       end
 
+      def column_definition_append_include_sql(sql, constraint)
+        if include_cols = constraint[:include]
+          sql << " INCLUDE " << literal(Array(include_cols))
+        end
+      end
+    
+      def column_definition_append_primary_key_sql(sql, constraint)
+        super
+        column_definition_append_include_sql(sql, constraint)
+      end
+
+      def column_definition_append_unique_sql(sql, constraint)
+        super
+        column_definition_append_include_sql(sql, constraint)
+      end
+
       # Literalize non-String collate options. This is because unquoted collatations
       # are folded to lowercase, and PostgreSQL used mixed case or capitalized collations.
       def column_definition_collate_sql(sql, column)
@@ -1339,24 +1357,40 @@ module Sequel
         when :exclude
           elements = constraint[:elements].map{|c, op| "#{literal(c)} WITH #{op}"}.join(', ')
           sql = String.new
-          sql << "#{"CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]}EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})#{" WHERE #{filter_expr(constraint[:where])}" if constraint[:where]}"
+          sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
+          sql << "EXCLUDE USING #{constraint[:using]||'gist'} (#{elements})"
+          column_definition_append_include_sql(sql, constraint)
+          sql << " WHERE #{filter_expr(constraint[:where])}" if constraint[:where]
           constraint_deferrable_sql_append(sql, constraint[:deferrable])
           sql
         when :primary_key, :unique
+          sql = String.new
+          sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
+
+          if type == :primary_key
+            sql << primary_key_constraint_sql_fragment(constraint)
+          else
+            sql << unique_constraint_sql_fragment(constraint)
+          end
+
           if using_index = constraint[:using_index]
-            sql = String.new
-            sql << "CONSTRAINT #{quote_identifier(constraint[:name])} " if constraint[:name]
-            if type == :primary_key
-              sql << primary_key_constraint_sql_fragment(constraint)
-            else
-              sql << unique_constraint_sql_fragment(constraint)
-            end
             sql << " USING INDEX " << quote_identifier(using_index)
           else
-            super
+            cols = literal(constraint[:columns])
+            cols.insert(-2, " WITHOUT OVERLAPS") if constraint[:without_overlaps]
+            sql << " " << cols
+
+            if include_cols = constraint[:include]
+              sql << " INCLUDE " << literal(Array(include_cols))
+            end
           end
+
+          sql
         else # when :foreign_key, :check
           sql = super
+          if constraint[:no_inherit]
+            sql << " NO INHERIT"
+          end
           if constraint[:not_enforced]
             sql << " NOT ENFORCED"
           end
@@ -1374,6 +1408,39 @@ module Sequel
         end
       end
 
+      def column_definition_null_sql(sql, column)
+        constraint = column[:not_null]
+        constraint = nil unless constraint.is_a?(Hash)
+        if constraint && (name = constraint[:name])
+          sql << " CONSTRAINT #{quote_identifier(name)}"
+        end
+        super
+        if constraint && constraint[:no_inherit]
+          sql << " NO INHERIT"
+        end
+      end
+
+      # Handle :period option
+      def column_references_table_constraint_sql(constraint)
+        sql = String.new
+        sql << "FOREIGN KEY "
+        cols = constraint[:columns]
+        cols = column_references_add_period(cols) if constraint[:period]
+        sql << literal(cols) << column_references_sql(constraint)
+      end
+
+      def column_references_append_key_sql(sql, column)
+        cols = Array(column[:key])
+        cols = column_references_add_period(cols) if column[:period]
+        sql << "(#{cols.map{|x| quote_identifier(x)}.join(', ')})"
+      end
+
+      def column_references_add_period(cols)
+        cols= cols.dup
+        cols[-1] = Sequel.lit("PERIOD #{quote_identifier(cols[-1])}")
+        cols
+      end
+  
       def database_specific_error_class_from_sqlstate(sqlstate)
         if sqlstate == '23P01'
           ExclusionConstraintViolation
@@ -1891,6 +1958,15 @@ module Sequel
         end
       end
 
+      # Support :nulls_not_distinct option.
+      def unique_constraint_sql_fragment(constraint)
+        if constraint[:nulls_not_distinct]
+          'UNIQUE NULLS NOT DISTINCT'
+        else
+          'UNIQUE'
+        end
+      end
+    
       # PostgreSQL 9.4+ supports views with check option.
       def view_with_check_option_support
         # :nocov:

data/lib/sequel/connection_pool/sharded_timed_queue.rb

@@ -140,6 +140,12 @@ class Sequel::ShardedTimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # The number of threads waiting to check out a connection for the given
+  # server.
+  def num_waiting(server=:default)
+    @queues[pick_server(server)].num_waiting
+  end
+
   # The total number of connections in the pool. Using a non-existant server will return nil.
   def size(server=:default)
     sync{@sizes[server]}

data/lib/sequel/connection_pool/timed_queue.rb

@@ -102,6 +102,11 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
     end
   end
 
+  # The number of threads waiting to check out a connection.
+  def num_waiting(_server=:default)
+    @queue.num_waiting
+  end
+
   def pool_type
     :timed_queue
   end

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
@@ -130,6 +135,8 @@ module Sequel
       #                 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
@@ -139,6 +146,10 @@ module Sequel
       #            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.
       #
@@ -182,6 +193,8 @@ 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)
@@ -214,6 +227,9 @@ module Sequel
       # 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
@@ -317,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)
@@ -360,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
@@ -447,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
@@ -504,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
@@ -614,9 +619,13 @@ module Sequel
     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])
-      sql << " " << primary_key_constraint_sql_fragment(constraint)
+      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 if column is a foreign key.
     def column_definition_references_sql(sql, column)
@@ -638,10 +647,14 @@ module Sequel
     def column_definition_add_unique_sql(sql, column)
       constraint = column_definition_constraint_hash(column, :unique)
       append_named_constraint_prefix_sql(sql, constraint[:name])
-      sql << ' ' << unique_constraint_sql_fragment(constraint)
+      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
@@ -678,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)

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.94.0
+  version: 5.95.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -329,6 +329,7 @@ files:
 - lib/sequel/plugins/boolean_subsets.rb
 - lib/sequel/plugins/caching.rb
 - lib/sequel/plugins/class_table_inheritance.rb
+- lib/sequel/plugins/class_table_inheritance_constraint_validations.rb
 - lib/sequel/plugins/column_conflicts.rb
 - lib/sequel/plugins/column_encryption.rb
 - lib/sequel/plugins/column_select.rb
@@ -448,7 +449,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []