sequel 5.93.0 → 5.94.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd35e8223b7f6d450cf4c1efeaad152236b4a1e360299aa46b03841bb45996c6
-  data.tar.gz: '096a62cc241cf6f48d0c2b3e0799402f21aa24a1196a332e022ef53ebaaeea85'
+  metadata.gz: 05c58f7009f56c4891e863d95ccd90eeb7acdc03f192979ff0d4a203fa1924d4
+  data.tar.gz: 957d465eebddd41b7de48475af26b04f4ae6fb387662257b97b9bdbc682eb197
 SHA512:
-  metadata.gz: 0b66c7e30dfb69468ad41bfe64de4e0442ad62590ea735b2e4bb591c46b949794a7a453c21532999c89296694f0136d9353041ec56fc470ab2ba0483f0534d61
-  data.tar.gz: 978dcd457829ff39f1ae9769dc574049cf29d07a2dbc8e307aa806a7b1954cd72432257de37d9e5236269b5746f615f8d0f7feb4979e9b86b619f582344afc29
+  metadata.gz: eb72cd090c58b8246b4a679082f9426f9aecf2d4815dffa2d96fe3be5a15b3e41b9ae7dd17effee49bfab82ac54c11d5d7d6aa67ff2a8aa54040145f5c72a3b0
+  data.tar.gz: 031fcb089d79550e485be488ec6d4b0d84024e4f686ebe953a08189c5b9d6e490c2351246b4258d8b78e9efafd013db61738f19e40a04afbb9fb1ec1796e5e6a

data/lib/sequel/adapters/ado/access.rb

@@ -281,7 +281,7 @@ module Sequel
           fetch_ado_schema(:columns, [nil,nil,table_name.to_s,nil]) do |row| 
             rows << AdoSchema::Column.new(row)
           end
-          rows.sort!{|a,b| a["ORDINAL_POSITION"] <=> b["ORDINAL_POSITION"]}
+          rows.sort_by! { |a| a["ORDINAL_POSITION"] }
         end
         
         def ado_schema_foreign_keys(table_name)
@@ -289,7 +289,7 @@ module Sequel
           fetch_ado_schema(:foreign_keys, [nil,nil,nil,nil,nil,table_name.to_s]) do |row| 
             rows << row
           end
-          rows.sort!{|a,b| a["ORDINAL"] <=> b["ORDINAL"]}
+          rows.sort_by! { |a| a["ORDINAL"] }
         end
         
         def fetch_ado_schema(type, criteria=[])

data/lib/sequel/adapters/ado.rb

@@ -234,7 +234,7 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::WIN32OLERuntimeError) && e.message =~ /Communication link failure/)
+        super || (e.is_a?(::WIN32OLERuntimeError) && e.message.include?('Communication link failure'))
       end
 
       def rollback_transaction(conn, opts=OPTS)

data/lib/sequel/adapters/ibmdb.rb

@@ -324,7 +324,7 @@ module Sequel
         when Numeric
           v.to_s
         when Date, Time
-          literal(v).gsub("'", '')
+          literal(v).delete("'")
         else
           v
         end

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -26,7 +26,7 @@ module Sequel
 
         # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
         def disconnect_error?(exception, opts)
-          exception.message =~ /\ACommunications link failure/ || super
+          exception.message.start_with?("Communications link failure") || super
         end
 
         # Get the last inserted id using LAST_INSERT_ID().
@@ -64,7 +64,7 @@ module Sequel
 
         # Convert tinyint(1) type to boolean
         def schema_column_type(db_type)
-          db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+          db_type.start_with?("tinyint(1)") ? :boolean : super
         end
       
         # Run the default connection setting SQL statements.

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -55,7 +55,7 @@ module Sequel
         end
 
         def disconnect_error?(exception, opts)
-          super || exception.message =~ /\AClosed Connection/
+          super || exception.message.start_with?("Closed Connection")
         end
 
         # Default the fetch size for statements to 100, similar to the oci8-based oracle adapter.

data/lib/sequel/adapters/jdbc/sqlite.rb

@@ -98,7 +98,7 @@ module Sequel
 
         # Whether the given exception is due to a foreign key error.
         def foreign_key_error?(exception)
-          exception.message =~ /query does not return ResultSet/
+          exception.message.include?('query does not return ResultSet')
         end
 
         # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.

data/lib/sequel/adapters/jdbc/sqlserver.rb

@@ -84,7 +84,7 @@ module Sequel
         end
 
         def disconnect_error?(exception, opts)
-          super || (exception.message =~ /connection is closed/)
+          super || (exception.message.include?('connection is closed'))
         end
       end
     end

data/lib/sequel/adapters/jdbc.rb

@@ -305,17 +305,31 @@ module Sequel
         m = output_identifier_meth
         schema, table = metadata_schema_and_table(table, opts)
         foreign_keys = {}
+
         metadata(:getImportedKeys, nil, schema, table) do |r|
-          if fk = foreign_keys[r[:fk_name]]
-            fk[:columns] << [r[:key_seq], m.call(r[:fkcolumn_name])]
-            fk[:key] << [r[:key_seq], m.call(r[:pkcolumn_name])]
-          elsif r[:fk_name]
-            foreign_keys[r[:fk_name]] = {:name=>m.call(r[:fk_name]), :columns=>[[r[:key_seq], m.call(r[:fkcolumn_name])]], :table=>m.call(r[:pktable_name]), :key=>[[r[:key_seq], m.call(r[:pkcolumn_name])]]}
+          next unless fk_name = r[:fk_name]
+
+          key_seq = r[:key_seq]
+          columns = [key_seq, m.call(r[:fkcolumn_name])]
+          key = [key_seq, m.call(r[:pkcolumn_name])]
+
+          if fk = foreign_keys[fk_name]
+            fk[:columns] << columns
+            fk[:key] << key
+          else
+            foreign_keys[fk_name] = {
+              :name=>m.call(fk_name),
+              :columns=>[columns],
+              :table=>m.call(r[:pktable_name]),
+              :key=>[key]
+            }
           end
         end
+
+        fk_keys = [:columns, :key]
         foreign_keys.values.each do |fk|
-          [:columns, :key].each do |k|
-            fk[k] = fk[k].sort.map{|_, v| v}
+          fk_keys.each do |k|
+            fk[k].sort!.map!{|_, v| v}
           end
         end
       end

data/lib/sequel/adapters/mysql.rb

@@ -290,7 +290,7 @@ module Sequel
       
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        convert_tinyint_to_bool && db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+        convert_tinyint_to_bool && db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
     

data/lib/sequel/adapters/mysql2.rb

@@ -221,13 +221,13 @@ module Sequel
         super ||
           ((conn = opts[:conn]) && !conn.ping) ||
           (e.is_a?(::Mysql2::Error) &&
-            (e.sql_state =~ /\A08/ ||
+            ((e.sql_state && e.sql_state.start_with?("08")) ||
              MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)))
       end
 
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        convert_tinyint_to_bool && db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+        convert_tinyint_to_bool && db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
 

data/lib/sequel/adapters/odbc.rb

@@ -81,7 +81,7 @@ module Sequel
       end
 
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::ODBC::Error) && /\A08S01/.match(e.message))
+        super || (e.is_a?(::ODBC::Error) && e.message.start_with?("08S01"))
       end
     end
     

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

@@ -108,7 +108,7 @@ module Sequel
         from(name).first
         true
       rescue DatabaseError => e
-        if e.to_s =~ /Operation not allowed for reason code "7" on table/ && v == false
+        if e.to_s.include?('Operation not allowed for reason code "7" on table') && v == false
           # table probably needs reorg
           reorg(name)
           v = true
@@ -175,8 +175,13 @@ module Sequel
       # Supply columns with NOT NULL if they are part of a composite
       # primary key or unique constraint
       def column_list_sql(g)
-        ks = []
-        g.constraints.each{|c| ks = c[:columns] if [:primary_key, :unique].include?(c[:type])} 
+        ks = {}
+        g.constraints.each do |c|
+          case c[:type]
+          when :primary_key, :unique
+            c[:columns].each{|c| ks[c] = true}
+          end
+        end
         g.columns.each{|c| c[:null] = false if ks.include?(c[:name]) }
         super
       end

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

@@ -705,7 +705,7 @@ module Sequel
 
       # Allows you to do a dirty read of uncommitted data using WITH (NOLOCK).
       def nolock
-        lock_style(:dirty)
+        cached_lock_style_dataset(:_nolock_ds, :dirty)
       end
 
       # Uses OUTER APPLY to join the given table into the current dataset.

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

@@ -456,7 +456,7 @@ module Sequel
               [pk]
             elsif !(pkc = generator.constraints.select{|con| con[:type] == :primary_key}).empty?
               pkc.first[:columns]
-            elsif !(pkc = generator.columns.select{|con| con[:primary_key] == true}).empty?
+            elsif !(pkc = generator.columns.select{|con| con[:primary_key]}).empty?
               pkc.map{|c| c[:name]}
             end
           else
@@ -787,7 +787,7 @@ module Sequel
 
       # Return a cloned dataset which will use LOCK IN SHARE MODE to lock returned rows.
       def for_share
-        lock_style(:share)
+        cached_lock_style_dataset(:_for_share_ds, :share)
       end
 
       # Adds full text filter

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

@@ -48,7 +48,7 @@ module Sequel
     TYPE_TRANSLATOR_DATE = date.freeze
     bytea = Object.new
     def bytea.call(str)
-      str = if str =~ /\A\\x/
+      str = if str.start_with?('\\x')
         # PostgreSQL 9.0+ bytea hex format
         str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
       else
@@ -141,6 +141,17 @@ module Sequel
         @operations << {:op => :add_constraint, :type => :exclude, :elements => elements}.merge!(opts)
       end
 
+      # Alter an existing constraint.  Options:
+      # :deferrable :: Modify deferrable setting for constraint (PostgreSQL 9.4+):
+      #                true :: DEFERRABLE INITIALLY DEFERRED
+      #                false :: NOT DEFERRABLE
+      #                :immediate :: DEFERRABLE INITIALLY IMMEDIATE
+      # :enforced :: Set true to use ENFORCED, or false to use NOT ENFORCED (PostgreSQL 18+)
+      # :inherit :: Set true to use INHERIT, or false to use NO INHERIT (PostgreSQL 18+)
+      def alter_constraint(name, opts=OPTS)
+        @operations << {:op => :alter_constraint, :name => name}.merge!(opts)
+      end
+
       # Validate the constraint with the given name, which should have
       # been added previously with NOT VALID.
       def validate_constraint(name)
@@ -335,7 +346,7 @@ module Sequel
         hash = {}
         _check_constraints_ds.where_each(:conrelid=>regclass_oid(table)) do |row|
           constraint = m.call(row[:constraint])
-          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
+          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[], :validated=>row[:validated], :enforced=>row[:enforced]}
           entry[:columns] << m.call(row[:column]) if row[:column]
         end
         
@@ -601,6 +612,8 @@ module Sequel
               :on_update=>fklod_map[row[:on_update]],
               :on_delete=>fklod_map[row[:on_delete]],
               :deferrable=>row[:deferrable],
+              :validated=>row[:validated],
+              :enforced=>row[:enforced],
               :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table]),
             }
 
@@ -898,11 +911,15 @@ module Sequel
 
       # Dataset used to retrieve CHECK constraint information
       def _check_constraints_ds
-        @_check_constraints_ds ||= metadata_dataset.
-          from{pg_constraint.as(:co)}.
-          left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
-          where(:contype=>'c').
-          select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+        @_check_constraints_ds ||= begin
+          ds = metadata_dataset.
+            from{pg_constraint.as(:co)}.
+            left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+            where(:contype=>'c').
+            select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+
+          _add_validated_enforced_constraint_columns(ds)
+        end
       end
 
       # Dataset used to retrieve foreign keys referenced by a table
@@ -968,6 +985,28 @@ module Sequel
           ds = ds.order_append(Sequel[:nsp][:nspname], Sequel[:cl2][:relname])
         end
 
+        _add_validated_enforced_constraint_columns(ds)
+      end
+
+      def _add_validated_enforced_constraint_columns(ds)
+        validated_cond = if server_version >= 90100
+          Sequel[:convalidated]
+        # :nocov:
+        else
+          Sequel.cast(true, TrueClass)
+        # :nocov:
+        end
+        ds = ds.select_append(validated_cond.as(:validated))
+
+        enforced_cond = if server_version >= 180000
+          Sequel[:conenforced]
+        # :nocov:
+        else
+          Sequel.cast(true, TrueClass)
+        # :nocov:
+        end
+        ds = ds.select_append(enforced_cond.as(:enforced))
+
         ds
       end
 
@@ -1140,6 +1179,31 @@ module Sequel
         "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end
 
+      def alter_table_alter_constraint_sql(table, op)
+        sql = String.new
+        sql << "ALTER CONSTRAINT #{quote_identifier(op[:name])}"
+        
+        constraint_deferrable_sql_append(sql, op[:deferrable])
+
+        case op[:enforced]
+        when nil
+        when false
+          sql << " NOT ENFORCED"
+        else
+          sql << " ENFORCED"
+        end
+
+        case op[:inherit]
+        when nil
+        when false
+          sql << " NO INHERIT"
+        else
+          sql << " INHERIT"
+        end
+
+        sql
+      end
+
       def alter_table_generator_class
         Postgres::AlterTableGenerator
       end
@@ -1233,9 +1297,9 @@ module Sequel
       end
 
       # PostgreSQL can't combine rename_column operations, and it can combine
-      # the custom validate_constraint operation.
+      # validate_constraint and alter_constraint operations.
       def combinable_alter_table_op?(op)
-        (super || op[:op] == :validate_constraint) && op[:op] != :rename_column
+        (super || op[:op] == :validate_constraint || op[:op] == :alter_constraint) && op[:op] != :rename_column
       end
 
       VALID_CLIENT_MIN_MESSAGES = %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze.each(&:freeze)
@@ -1269,7 +1333,7 @@ module Sequel
         sqls
       end
 
-      # Handle exclusion constraints.
+      # Handle PostgreSQL-specific constraint features.
       def constraint_definition_sql(constraint)
         case type = constraint[:type]
         when :exclude
@@ -1293,6 +1357,9 @@ module Sequel
           end
         else # when :foreign_key, :check
           sql = super
+          if constraint[:not_enforced]
+            sql << " NOT ENFORCED"
+          end
           if constraint[:not_valid]
             sql << " NOT VALID"
           end
@@ -1300,6 +1367,13 @@ module Sequel
         end
       end
 
+      def column_definition_add_references_sql(sql, column)
+        super
+        if column[:not_enforced]
+          sql << " NOT ENFORCED"
+        end
+      end
+
       def database_specific_error_class_from_sqlstate(sqlstate)
         if sqlstate == '23P01'
           ExclusionConstraintViolation
@@ -1369,7 +1443,8 @@ module Sequel
       # SQL statement to create database function.
       def create_function_sql(name, definition, opts=OPTS)
         args = opts[:args]
-        if !opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 and %w'OUT INOUT'.include?(a[2].to_s)}
+        in_out = %w'OUT INOUT'
+        if (!opts[:args].is_a?(Array) || !opts[:args].any?{|a| Array(a).length == 3 && in_out.include?(a[2].to_s)})
           returns = opts[:returns] || 'void'
         end
         language = opts[:language] || 'SQL'
@@ -1932,9 +2007,22 @@ module Sequel
         end
       end
 
+      # Return a cloned dataset which will use FOR KEY SHARE to lock returned rows.
+      # Supported on PostgreSQL 9.3+.
+      def for_key_share
+        cached_lock_style_dataset(:_for_key_share_ds, :key_share)
+      end
+
+      # Return a cloned dataset which will use FOR NO KEY UPDATE to lock returned rows.
+      # This is generally a better choice than using for_update on PostgreSQL, unless
+      # you will be deleting the row or modifying a key column. Supported on PostgreSQL 9.3+.
+      def for_no_key_update
+        cached_lock_style_dataset(:_for_no_key_update_ds, :no_key_update)
+      end
+
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
       def for_share
-        lock_style(:share)
+        cached_lock_style_dataset(:_for_share_ds, :share)
       end
 
       # Run a full text search on PostgreSQL.  By default, searching for the inclusion
@@ -2710,8 +2798,13 @@ module Sequel
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
         lock = @opts[:lock]
-        if lock == :share
+        case lock
+        when :share
           sql << ' FOR SHARE'
+        when :no_key_update
+          sql << ' FOR NO KEY UPDATE'
+        when :key_share
+          sql << ' FOR KEY SHARE'
         else
           super
         end

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

@@ -95,14 +95,14 @@ module Sequel
         metadata_dataset.with_sql("PRAGMA index_list(?)", im.call(table)).each do |r|
           if opts[:only_autocreated]
             # If specifically asked for only autocreated indexes, then return those an only those
-            next unless r[:name] =~ /\Asqlite_autoindex_/
+            next unless r[:name].start_with?('sqlite_autoindex_')
           elsif r.has_key?(:origin)
             # If origin is set, then only exclude primary key indexes and partial indexes
             next if r[:origin] == 'pk'
             next if r[:partial].to_i == 1
           else
             # When :origin key not present, assume any autoindex could be a primary key one and exclude it
-            next if r[:name] =~ /\Asqlite_autoindex_/
+            next if r[:name].start_with?('sqlite_autoindex_')
           end
 
           indexes[m.call(r[:name])] = {:unique=>r[:unique].to_i==1}
@@ -302,7 +302,7 @@ module Sequel
 
       # A name to use for the backup table
       def backup_table_name(table, opts=OPTS)
-        table = table.gsub('`', '')
+        table = table.delete('`')
         (opts[:times]||1000).times do |i|
           table_name = "#{table}_backup#{i}"
           return table_name unless table_exists?(table_name)

data/lib/sequel/adapters/tinytds.rb

@@ -14,7 +14,7 @@ module Sequel
         opts = server_opts(server)
         opts[:username] = opts[:user]
         c = TinyTds::Client.new(opts)
-        c.query_options.merge!(:cache_rows=>false)
+        c.query_options[:cache_rows] = false
 
         # SEQUEL6: Default to ansi: true
         if opts[:ansi]

data/lib/sequel/adapters/trilogy.rb

@@ -83,7 +83,7 @@ module Sequel
 
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        db_type =~ /\Atinyint\(1\)/ ? :boolean : super
+        db_type.start_with?("tinyint(1)") ? :boolean : super
       end
     end
 

data/lib/sequel/connection_pool/timed_queue.rb

@@ -236,7 +236,7 @@ class Sequel::TimedQueueConnectionPool < Sequel::ConnectionPool
   def preconnect(concurrent = false)
     if concurrent
       if times = sync{@max_size > (size = @size[0]) ? @max_size - size : false}
-        times.times.map{Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
+        Array.new(times){Thread.new{if conn = try_make_new; @queue.push(conn) end}}.map(&:value)
       end
     else
       while conn = try_make_new

data/lib/sequel/core.rb

@@ -403,7 +403,7 @@ module Sequel
       when -1, 0
         vr.instance_exec(&block)
       else
-        block.call(vr)
+        yield(vr)
       end  
     end
 

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

@@ -126,17 +126,21 @@ 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.
+      # :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.
+      # :unique_constraint_name :: Older option to name unique constraint.
+      # :unique_deferrable :: Older option to set unique constraint as deferrable.
       #
       # PostgreSQL specific options:
       #
@@ -178,6 +182,7 @@ module Sequel
       # :deferrable :: Whether the CHECK constraint should be marked DEFERRABLE.
       #
       # PostgreSQL specific options:
+      # :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 +202,18 @@ 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.
       #
       #   foreign_key([:artist_name, :artist_location], :artists, name: :artist_fk)
       #   # ADD CONSTRAINT artist_fk FOREIGN KEY (artist_name, artist_location) REFERENCES artists

data/lib/sequel/database/schema_methods.rb

@@ -605,36 +605,63 @@ 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])
+      sql << " " << primary_key_constraint_sql_fragment(constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
     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])
+      sql << ' ' << unique_constraint_sql_fragment(constraint)
+      constraint_deferrable_sql_append(sql, constraint[:deferrable])
+    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.
@@ -677,7 +704,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 +760,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/constraint_validations.rb

@@ -164,7 +164,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

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 = 94
 
   # 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.93.0
+  version: 5.94.0
 platform: ruby
 authors:
 - Jeremy Evans