sequel 5.79.0 → 5.81.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 154517820668c8c59f141797157a9945ae3afaeb482e997619e68e9bebc5c70a
-  data.tar.gz: c7991308e696d0f931f46cf38c301986c9094a44bca94a1d6749a0b798cb1d9c
+  metadata.gz: a23afa1510b7bd1ba6918319eedce156450672520ab4798e6de56461a59660e1
+  data.tar.gz: bb6bbfbf0f1f82fe117fa8c725e9cf4fde49644a74b463ab8682018744a8a1de
 SHA512:
-  metadata.gz: 7efb6286d8eded4c0064199f7335e9cd2b0575942fd52040b29c52e26498d1531168435d86ca6e42474512ac21c1b151db85dd4db0fa5ff6b3f90dad73568a3b
-  data.tar.gz: 7ef17f79333fdabe90485b105fdc24925c8c75f41dc78f83f5400ebc39b0ac2b3709881624086526559132c8346c1dc8f07b9384a39bb838d1132bf4a7040ec1
+  metadata.gz: 9e26620f8f1df2715205e9019c2012ec2e9f392d14ed427d66c76f488bccc3e5d3f27e4d626a47d54903d611695db0487f987d99191602024a1864d6c10f7bde
+  data.tar.gz: cd070d8c35960949039d226b5eaf8c90ebec8d0cef3f09b5dae533551bb35170ca6e2503d88f1b1512110b6617ff9c03d9cb2afb62395c4d953314aa5a5ca87c

data/CHANGELOG

@@ -1,3 +1,19 @@
+=== 5.81.0 (2024-06-01)
+
+* Fix ignored block warnings in a couple plugin apply methods on Ruby 3.4 (jeremyevans)
+
+* Skip Ruby internal caller locations when searching for caller locations in caller_logging and provenance extensions (jeremyevans) 
+
+* Add temporarily_release_connection Database extension for multithreaded transactional testing (jeremyevans)
+
+=== 5.80.0 (2024-05-01)
+
+* Support Dataset#skip_locked on MariaDB 10.6+ (simi) (#2150)
+
+* Avoid allocating datasets in cases where the returned dataset would be the same as the receiver (jeremyevans)
+
+* Add provenance dataset extension, which includes comments in queries showing how and where the dataset was built (jeremyevans)
+
 === 5.79.0 (2024-04-01)
 
 * Support create_or_replace_view with :materialized option on PostgreSQL (nashby) (#2144)

data/doc/code_order.rdoc

@@ -91,9 +91,11 @@ unsafe runtime modification of the configuration:
   model_classes.each(&:freeze)
   DB.freeze
 
-The `subclasses` plugin can be used to keep track of all model classes
-that have been setup in your application. Finalizing their associations
-and freezing them can easily be achieved through the plugin:
+`model_classes` is not a Sequel method, it indicates an array of model
+classes you defined. Instead of listing them manually, the `subclasses`
+plugin can be used to keep track of all model classes that have been
+setup in your application. Finalizing their associations and freezing
+them can easily be achieved through the plugin:
 
   # Register the plugin before setting up the models
   Sequel::Model.plugin :subclasses

data/doc/release_notes/5.80.0.txt

@@ -0,0 +1,40 @@
+= New Features
+
+* A provenance dataset extension has been added. This extension makes
+  SQL queries include a comment describing how the dataset was built.
+  This can make debugging complex cases significantly easier. Here's
+  a simple example:
+
+    DB.extension :provenance
+
+    DB[:table].
+      select(:a).
+      where{b > 10}.
+      order(:c).
+      limit(10)
+      # SQL:
+      # SELECT a FROM table WHERE (b > 10) ORDER BY c LIMIT 10 --
+      #  -- Dataset Provenance
+      #  -- Keys:[:from] Source:(eval at bin/sequel:257):2:in `<main>'
+      #  -- Keys:[:select] Source:(eval at bin/sequel:257):3:in `<main>'
+      #  -- Keys:[:where] Source:(eval at bin/sequel:257):4:in `<main>'
+      #  -- Keys:[:order] Source:(eval at bin/sequel:257):5:in `<main>'
+      #  -- Keys:[:limit] Source:(eval at bin/sequel:257):6:in `<main>'
+
+  With the above example, it's obvious how the dataset is created, but
+  but in real applications, where datasets can be built from multiple
+  files, seeing where each dataset clone was made can be helpful.
+
+  The source listed will skip locations in the Ruby standard library
+  as well as Sequel itself.  Other locations can be skipped by
+  providing a Database :provenance_caller_ignore Regexp option:
+
+    DB.opts[:provenance_caller_ignore] = /\/gems\/library_name-/
+
+= Other Improvements
+
+* For dataset methods where Sequel can determine that the return
+  value would be equivalent to the receiver, Sequel now returns the
+  receiver.  This reduces the number of dataset allocations.
+
+* Sequel now supports Dataset#skip_locked on MariaDB 10.6+.

data/doc/release_notes/5.81.0.txt

@@ -0,0 +1,31 @@
+= New Features
+
+* A temporarily_release_connection Database extension has been added,
+  designed for multithreaded transactional testing.
+
+  This allows one thread to start a transaction, and then release
+  the connection back for usage by the connection pool, so that
+  other threads can operate on the connection object safely inside
+  the transaction.  This requires the connection pool be limited
+  to a single connection, to ensure that the released connection
+  can be reacquired.  It's not perfect, because if the connection
+  is disconnected and removed from the pool while temporarily
+  released, there is no way to handle that situation correctly.
+  Example:
+
+    DB.transaction(rollback: :always, auto_savepoint: true) do |conn|
+      DB.temporarily_release_connection(conn) do
+        # Other threads can operate on connection safely inside
+        # the transaction
+        yield
+      end
+    end
+
+= Other Improvements
+
+* In the caller_logging and provenance extensions, Ruby internal
+  caller locations are skipped when trying to locate the appropriate
+  caller line to include.
+
+* A couple ignored block warnings in plugin apply methods have been
+  fixed on Ruby 3.4.

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

@@ -926,9 +926,9 @@ module Sequel
         (type == :insert && db.mariadb? && db.adapter_scheme != :jdbc) ? (db.server_version >= 100500) : false
       end
 
-      # MySQL 8+ supports SKIP LOCKED.
+      # MySQL 8+ and MariaDB 10.6+ support SKIP LOCKED.
       def supports_skip_locked?
-        !db.mariadb? && db.server_version >= 80000
+        db.server_version >= (db.mariadb? ? 100600 : 80000)
       end
 
       # Check the database setting for whether fractional timestamps

data/lib/sequel/dataset/graph.rb

@@ -253,6 +253,7 @@ module Sequel
     # Remove the splitting of results into subhashes, and all metadata
     # related to the current graph (if any).
     def ungraphed
+      return self unless opts[:graph]
       clone(:graph=>nil)
     end
 

data/lib/sequel/dataset/query.rb

@@ -129,6 +129,7 @@ module Sequel
     def distinct(*args, &block)
       virtual_row_columns(args, block)
       if args.empty?
+        return self if opts[:distinct] == EMPTY_ARRAY
         cached_dataset(:_distinct_ds){clone(:distinct => EMPTY_ARRAY)}
       else
         raise(InvalidOperation, "DISTINCT ON not supported") unless supports_distinct_on?
@@ -230,6 +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)}
     end
 
@@ -641,6 +643,7 @@ module Sequel
     #   DB.from(:a, DB[:b].where(Sequel[:a][:c]=>Sequel[:b][:d]).lateral)
     #   # SELECT * FROM a, LATERAL (SELECT * FROM b WHERE (a.c = b.d))
     def lateral
+      return self if opts[:lateral]
       cached_dataset(:_lateral_ds){clone(:lateral=>true)}
     end
 
@@ -744,6 +747,7 @@ module Sequel
     #   ds.all # => [{2=>:id}]
     #   ds.naked.all # => [{:id=>2}]
     def naked
+      return self unless opts[:row_proc]
       cached_dataset(:_naked_ds){with_row_proc(nil)}
     end
 
@@ -753,6 +757,7 @@ module Sequel
     #   DB[:items].for_update.nowait
     #   # SELECT * FROM items FOR UPDATE NOWAIT
     def nowait
+      return self if opts[:nowait]
       cached_dataset(:_nowait_ds) do
         raise(Error, 'This dataset does not support raises errors instead of waiting for locked rows') unless supports_nowait?
         clone(:nowait=>true)
@@ -878,6 +883,7 @@ module Sequel
     #   end
     def returning(*values)
       if values.empty?
+        return self if opts[:returning] == EMPTY_ARRAY
         cached_dataset(:_returning_ds) do
           raise Error, "RETURNING is not supported on #{db.database_type}" unless supports_returning?(:insert)
           clone(:returning=>EMPTY_ARRAY)
@@ -930,6 +936,7 @@ module Sequel
     #   DB[:items].select_all(:items, :foo) # SELECT items.*, foo.* FROM items
     def select_all(*tables)
       if tables.empty?
+        return self unless opts[:select]
         cached_dataset(:_select_all_ds){clone(:select => nil)}
       else
         select(*tables.map{|t| i, a = split_alias(t); a || i}.map!{|t| SQL::ColumnAll.new(t)}.freeze)
@@ -1005,6 +1012,7 @@ module Sequel
 
     # Specify that the check for limits/offsets when updating/deleting be skipped for the dataset.
     def skip_limit_check
+      return self if opts[:skip_limit_check]
       cached_dataset(:_skip_limit_check_ds) do
         clone(:skip_limit_check=>true)
       end
@@ -1012,6 +1020,7 @@ module Sequel
 
     # Skip locked rows when returning results from this dataset.
     def skip_locked
+      return self if opts[:skip_locked]
       cached_dataset(:_skip_locked_ds) do
         raise(Error, 'This dataset does not support skipping locked rows') unless supports_skip_locked?
         clone(:skip_locked=>true)
@@ -1023,6 +1032,7 @@ module Sequel
     #   DB[:items].group(:a).having(a: 1).where(:b).unfiltered
     #   # SELECT * FROM items GROUP BY a
     def unfiltered
+      return self unless opts[:where] || opts[:having]
       cached_dataset(:_unfiltered_ds){clone(:where => nil, :having => nil)}
     end
 
@@ -1031,6 +1041,7 @@ module Sequel
     #   DB[:items].group(:a).having(a: 1).where(:b).ungrouped
     #   # SELECT * FROM items WHERE b
     def ungrouped
+      return self unless opts[:group] || opts[:having]
       cached_dataset(:_ungrouped_ds){clone(:group => nil, :having => nil)}
     end
 
@@ -1058,6 +1069,7 @@ module Sequel
     # 
     #   DB[:items].limit(10, 20).unlimited # SELECT * FROM items
     def unlimited
+      return self unless opts[:limit] || opts[:offset]
       cached_dataset(:_unlimited_ds){clone(:limit=>nil, :offset=>nil)}
     end
 
@@ -1065,6 +1077,7 @@ module Sequel
     # 
     #   DB[:items].order(:a).unordered # SELECT * FROM items
     def unordered
+      return self unless opts[:order]
       cached_dataset(:_unordered_ds){clone(:order=>nil)}
     end
     

data/lib/sequel/extensions/caller_logging.rb

@@ -36,6 +36,8 @@ require 'rbconfig'
 module Sequel
   module CallerLogging
     SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
+    RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+    INTERNAL = '<internal'
 
     # A regexp of caller lines to ignore, in addition to internal Sequel and Ruby code.
     attr_accessor :caller_logging_ignore
@@ -59,7 +61,8 @@ module Sequel
       ignore = caller_logging_ignore
       c = caller.find do |line|
         !(line.start_with?(SEQUEL_LIB_PATH) ||
-          line.start_with?(RbConfig::CONFIG["rubylibdir"]) ||
+          line.start_with?(RUBY_STDLIB) ||
+          line.start_with?(INTERNAL) ||
           (ignore && line =~ ignore))
       end
 

data/lib/sequel/extensions/provenance.rb

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+#
+# The provenance dataset extension tracks the locations of all
+# dataset clones that resulted in the current dataset, and includes
+# the information as a comment in the dataset's SQL.  This makes it
+# possible to see how a query was built, which can aid debugging.
+# Example:
+#
+#   DB[:table].
+#     select(:a).
+#     where{b > 10}.
+#     order(:c).
+#     limit(10)
+#   # SQL:
+#   # SELECT a FROM table WHERE (b > 10) ORDER BY c LIMIT 10 --
+#   #  -- Dataset Provenance
+#   #  -- Keys:[:from] Source:(eval at bin/sequel:257):2:in `<main>'
+#   #  -- Keys:[:select] Source:(eval at bin/sequel:257):3:in `<main>'
+#   #  -- Keys:[:where] Source:(eval at bin/sequel:257):4:in `<main>'
+#   #  -- Keys:[:order] Source:(eval at bin/sequel:257):5:in `<main>'
+#   #  -- Keys:[:limit] Source:(eval at bin/sequel:257):6:in `<main>'
+#
+# With the above example, the source is fairly obvious and not helpful,
+# but in real applications, where datasets can be built from multiple
+# files, seeing where each dataset clone was made can be helpful.
+#
+# The Source listed will skip locations in the Ruby standard library
+# as well as Sequel itself.  Other locations can be skipped by
+# providing a Database :provenance_caller_ignore Regexp option:
+#
+#   DB.opts[:provenance_caller_ignore] = /\/gems\/library_name-/
+#
+# Related module: Sequel::Dataset::Provenance
+
+#
+module Sequel
+  class Dataset
+    module Provenance
+      SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
+      RUBY_STDLIB = RbConfig::CONFIG["rubylibdir"]
+      INTERNAL = '<internal'
+
+      if TRUE_FREEZE
+        # Include provenance information when cloning datasets.
+        def clone(opts = nil || (return self))
+          super(provenance_opts(opts))
+        end
+      else
+        # :nocov:
+        def clone(opts = OPTS) # :nodoc:
+          super(provenance_opts(opts))
+        end
+        # :nocov:
+      end
+
+      %w'select insert update delete'.each do |type|
+        # Include the provenance information as a comment when preparing dataset SQL
+        define_method(:"#{type}_sql") do |*a|
+          sql = super(*a)
+
+          if provenance = @opts[:provenance]
+            comment = provenance.map do |hash|
+              " -- Keys:#{hash[:keys].inspect} Source:#{hash[:source]}".to_s.gsub(/\s+/, ' ')
+            end
+            comment << ""
+            comment.unshift " -- Dataset Provenance"
+            comment.unshift " -- "
+            comment = comment.join("\n")
+
+            if sql.frozen?
+              sql += comment
+              sql.freeze
+            elsif @opts[:append_sql] || @opts[:placeholder_literalizer]
+              sql << comment
+            else
+              sql += comment
+            end
+          end
+
+          sql
+        end
+      end
+
+      private
+
+      # Return a copy of opts with provenance information added.
+      def provenance_opts(opts)
+        provenance = {source: provenance_source, keys: opts.keys.freeze}.freeze
+        opts = opts.dup
+        opts[:provenance] = ((@opts[:provenance] || EMPTY_ARRAY).dup << provenance).freeze
+        opts
+      end
+
+      # Return the caller line for the provenance change. This skips
+      # Sequel itself and the standard library.  Additional locations
+      # can be skipped using the :provenance_caller_ignore Dataset option.
+      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) ||
+            (ignore && line =~ ignore))
+        end
+      end
+    end
+
+    register_extension(:provenance, Provenance)
+  end
+end

data/lib/sequel/extensions/temporarily_release_connection.rb

@@ -0,0 +1,178 @@
+# frozen-string-literal: true
+#
+# The temporarily_release_connection extension adds support for temporarily
+# releasing a checked out connection back to the connection pool.  It is
+# designed for use in multithreaded transactional integration tests, allowing
+# a connection to start a transaction in one thread, but be temporarily
+# released back to the connection pool, so it can be operated on safely
+# by multiple threads inside a block. For example, the main thread could be
+# running tests that send web requests, and a separate thread running a web
+# server that is responding to those requests, and the same connection and
+# transaction would be used for both.
+#
+# To load the extension into the database:
+#
+#   DB.extension :temporarily_release_connection
+#
+# After the extension is loaded, call the +temporarily_release_connection+
+# method with the connection object to temporarily release the connection
+# back to the pool. Example:
+#
+#   DB.transaction(rollback: :always, auto_savepoint: true) do |conn|
+#     DB.temporarily_release_connection(conn) do
+#       # Other threads can operate on connection safely inside the transaction
+#       yield
+#     end
+#   end
+#
+# For sharded connection pools, the second argument to +temporarily_release_connection+
+# is respected, and specifies the server on which to temporarily release the connection.
+#
+# The temporarily_release_connection extension is only supported with the
+# threaded and timed_queue connection pools that ship with Sequel (and the sharded
+# versions of each).  To make sure that same connection object can be reacquired, it
+# is only supported if the maximum connection pool size is 1, so set the Database
+# :max_connections option to 1 if you plan to use this extension.
+#
+# If the +temporarily_release_connection+ method cannot reacquire the same connection
+# it released to the pool, it will raise a Sequel::UnableToReacquireConnectionError
+# exception.  This should only happen if the connection has been disconnected
+# while it was temporarily released.  If this error is raised, Database#transaction
+# will not rollback the transaction, since the connection object is likely no longer
+# valid, and on poorly written database drivers, that could cause the process to crash.
+#
+# Related modules: Sequel::TemporarilyReleaseConnection,
+# Sequel::UnableToReacquireConnectionError
+
+#
+module Sequel
+  # Error class raised if the connection pool does not provide the same connection
+  # object when checking a temporarily released connection out.
+  class UnableToReacquireConnectionError < Error
+  end
+
+  module TemporarilyReleaseConnection
+    module DatabaseMethods
+      # Temporarily release the connection back to the connection pool for the
+      # duration of the block.
+      def temporarily_release_connection(conn, server=:default, &block)
+        pool.temporarily_release_connection(conn, server, &block)
+      end
+
+      private
+
+      # Do nothing if UnableToReacquireConnectionError is raised, as it is
+      # likely the connection is not in a usable state.
+      def rollback_transaction(conn, opts)
+        return if UnableToReacquireConnectionError === $!
+        super
+      end
+    end
+
+    module PoolMethods
+      # Temporarily release a currently checked out connection, then yield to the block. Reacquire the same
+      # connection upon the exit of the block.
+      def temporarily_release_connection(conn, server)
+        t = Sequel.current
+        raise Error, "connection not currently checked out" unless conn.equal?(trc_owned_connection(t, server))
+
+        begin
+          trc_release(t, conn, server)
+          yield
+        ensure
+          c = trc_acquire(t, server)
+          unless conn.equal?(c)
+            raise UnableToReacquireConnectionError, "reacquired connection not the same as initial connection"
+          end
+        end
+      end
+    end
+
+    module TimedQueue
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t)
+      end
+
+      def trc_release(t, conn, server)
+        release(t)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t)
+      end
+    end
+
+    module ShardedTimedQueue
+      # Normalize the server name for sharded connection pools
+      def temporarily_release_connection(conn, server)
+        server = pick_server(server)
+        super
+      end
+
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t, server)
+      end
+
+      def trc_release(t, conn, server)
+        release(t, conn, server)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t, server)
+      end
+    end
+
+    module ThreadedBase
+      private
+
+      def trc_release(t, conn, server)
+        sync{super}
+      end
+    end
+
+    module Threaded
+      include TimedQueue
+      include ThreadedBase
+    end
+
+    module ShardedThreaded
+      include ShardedTimedQueue
+      include ThreadedBase
+    end
+  end
+
+  trc = TemporarilyReleaseConnection
+  trc_map = {
+    :threaded => trc::Threaded,
+    :sharded_threaded => trc::ShardedThreaded,
+    :timed_queue => trc::TimedQueue,
+    :sharded_timed_queue => trc::ShardedTimedQueue,
+  }.freeze
+
+  Database.register_extension(:temporarily_release_connection) do |db|
+    unless pool_mod = trc_map[db.pool.pool_type]
+      raise(Error, "temporarily_release_connection extension not supported for connection pool type #{db.pool.pool_type}")
+    end
+
+    case db.pool.pool_type
+    when :threaded, :sharded_threaded
+      if db.opts[:connection_handling] == :disconnect
+        raise Error, "temporarily_release_connection extension not supported with connection_handling: :disconnect option"
+      end
+    end
+
+    unless db.pool.max_size == 1
+      raise Error, "temporarily_release_connection extension not supported unless :max_connections option is 1"
+    end
+
+    db.extend(trc::DatabaseMethods)
+    db.pool.extend(trc::PoolMethods)
+    db.pool.extend(pool_mod)
+  end
+
+  private_constant :TemporarilyReleaseConnection
+end

data/lib/sequel/plugins/column_encryption.rb

@@ -586,7 +586,7 @@ module Sequel
         end
       end
 
-      def self.apply(model, opts=OPTS)
+      def self.apply(model, opts=OPTS, &_)
         model.plugin :serialization
       end
 

data/lib/sequel/plugins/input_transformer.rb

@@ -24,7 +24,7 @@ module Sequel
     #   # Make the Album class support input transformers 
     #   Album.plugin :input_transformer
     module InputTransformer
-      def self.apply(model, *)
+      def self.apply(model, *, &_)
         model.instance_exec do
           @input_transformers = {}
           @skip_input_transformer_columns = {}

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.79.0
+  version: 5.81.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-01 00:00:00.000000000 Z
+date: 2024-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -227,6 +227,8 @@ extra_rdoc_files:
 - doc/release_notes/5.78.0.txt
 - doc/release_notes/5.79.0.txt
 - doc/release_notes/5.8.0.txt
+- doc/release_notes/5.80.0.txt
+- doc/release_notes/5.81.0.txt
 - doc/release_notes/5.9.0.txt
 files:
 - CHANGELOG
@@ -334,6 +336,8 @@ files:
 - doc/release_notes/5.78.0.txt
 - doc/release_notes/5.79.0.txt
 - doc/release_notes/5.8.0.txt
+- doc/release_notes/5.80.0.txt
+- doc/release_notes/5.81.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc
 - doc/security.rdoc
@@ -496,6 +500,7 @@ files:
 - lib/sequel/extensions/pg_static_cache_updater.rb
 - lib/sequel/extensions/pg_timestamptz.rb
 - lib/sequel/extensions/pretty_table.rb
+- lib/sequel/extensions/provenance.rb
 - lib/sequel/extensions/query.rb
 - lib/sequel/extensions/round_timestamps.rb
 - lib/sequel/extensions/run_transaction_hooks.rb
@@ -519,6 +524,7 @@ files:
 - lib/sequel/extensions/symbol_as.rb
 - lib/sequel/extensions/symbol_as_refinement.rb
 - lib/sequel/extensions/synchronize_sql.rb
+- lib/sequel/extensions/temporarily_release_connection.rb
 - lib/sequel/extensions/thread_local_timezones.rb
 - lib/sequel/extensions/to_dot.rb
 - lib/sequel/extensions/transaction_connection_validator.rb
@@ -666,7 +672,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: The Database Toolkit for Ruby