sequel 5.88.0 → 5.90.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a4a563fddfd5332195e8b9ba2588aef535f27ea0cee15f43afdc877910775ba
-  data.tar.gz: 47cb743d96f031e4fa7e415708473158b2f564b3faa155335a4787e79bce34bd
+  metadata.gz: ba9973675e3b9e358ff96c334052ab6ba73e1db4c87c455163b60e367d0eb568
+  data.tar.gz: 86c4197ba9ced0d6bd3a789e5c20e4d0656bf5baca103f0b6db33e45b7981258
 SHA512:
-  metadata.gz: b3dd656f73cdf525bda28a2cb5f136f91ae2935f48cfd94f8dc06f042b7f682c2faf48a48625b7845ae058b92189447433c152ab11eeebb8baae925d5371326d
-  data.tar.gz: 84ae987e64b8c872351d259d88a1e8b63b7926e06f9bda7a0d71dda4826e4e17c83fdc5538bcde63cc0d16f77ffd75c57b504947a692898d552a77e1814a7c44
+  metadata.gz: 0247f84faceeb8a8c97d85bdefc3d0b781986e630981c163ca58bf7965f852a472d9e9501c5913ee1f4e7b02c005817c76ae8e71fcb0479fae252b27662e05f7
+  data.tar.gz: f90672de6e1ae901dca735988fa1466647bdc8f0cfeba75c1f27892e14e4eaf316b0141906039c9a33a70150b1860cda1f7a1972858ece6e3752614a91a60f2c

data/lib/sequel/adapters/ibmdb.rb

@@ -7,6 +7,7 @@ module Sequel
 
   module IBMDB
     tt = Class.new do
+      Sequel.set_temp_name(self){"Sequel::IBMDB::_TypeTranslator"}
       def boolean(s) !s.to_i.zero? end
       def int(s) s.to_i end
     end.new

data/lib/sequel/adapters/mysql2.rb

@@ -97,7 +97,14 @@ module Sequel
           synchronize(opts[:server]) do |conn|
             stmt, ps_sql = conn.prepared_statements[ps_name]
             unless ps_sql == sql
-              stmt.close if stmt
+              if stmt
+                begin
+                  stmt.close
+                rescue ::Mysql2::Error
+                  # probably Invalid statement handle, can happen from dropping
+                  # related table, ignore as we won't be using it again.
+                end
+              end
               stmt = log_connection_yield("Preparing #{ps_name}: #{sql}", conn){conn.prepare(sql)}
               conn.prepared_statements[ps_name] = [stmt, sql]
             end

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

@@ -88,6 +88,7 @@ module Sequel
   
     module DatasetMethods
       include(Module.new do
+        Sequel.set_temp_name(self){"Sequel::Access::DatasetMethods::_SQLMethods"}
         Dataset.def_sql_method(self, :select, %w'select distinct limit columns into from join where group order having compounds')
       end)
       include EmulateOffsetWithReverseAndCount

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

@@ -574,6 +574,7 @@ module Sequel
   
     module DatasetMethods
       include(Module.new do
+        Sequel.set_temp_name(self){"Sequel::MSSQL::DatasetMethods::_SQLMethods"}
         Dataset.def_sql_method(self, :select, %w'with select distinct limit columns into from lock join where group having compounds order')
       end)
       include EmulateOffsetWithRowNumber

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

@@ -333,6 +333,7 @@ module Sequel
       BITAND_PROC = lambda{|a, b| Sequel.lit(["CAST(BITAND(", ", ", ") AS INTEGER)"], a, b)}
 
       include(Module.new do
+        Sequel.set_temp_name(self){"Sequel::Oracle::DatasetMethods::_SQLMethods"}
         Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order limit lock')
       end)
 

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

@@ -1271,21 +1271,32 @@ module Sequel
 
       # Handle exclusion constraints.
       def constraint_definition_sql(constraint)
-        case constraint[:type]
+        case type = constraint[:type]
         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]}"
           constraint_deferrable_sql_append(sql, constraint[:deferrable])
           sql
-        when :foreign_key, :check
+        when :primary_key, :unique
+          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
+          end
+        else # when :foreign_key, :check
           sql = super
           if constraint[:not_valid]
             sql << " NOT VALID"
           end
           sql
-        else
-          super
         end
       end
 

data/lib/sequel/core.rb

@@ -164,6 +164,21 @@ module Sequel
       JSON::ParserError
     end
 
+    if RUBY_VERSION >= '3.3'
+      # Create a new module using the block, and set the temporary name
+      # on it using the given a containing module and name.
+      def set_temp_name(mod)
+        mod.set_temporary_name(yield)
+        mod
+      end
+    # :nocov:
+    else
+      def set_temp_name(mod)
+        mod
+      end
+    end
+    # :nocov:
+
     # Convert given object to json and return the result.
     # This can be overridden to use an alternative json implementation.
     def object_to_json(obj, *args, &block)

data/lib/sequel/database/dataset_defaults.rb

@@ -17,7 +17,7 @@ module Sequel
     # as the dataset class.
     def dataset_class=(c)
       unless @dataset_modules.empty?
-        c = Class.new(c)
+        c = Sequel.set_temp_name(Class.new(c)){"Sequel::Dataset::_Subclass"}
         @dataset_modules.each{|m| c.send(:include, m)}
       end
       @dataset_class = c
@@ -61,10 +61,10 @@ module Sequel
     #   # SELECT id, name FROM table WHERE active ORDER BY id
     def extend_datasets(mod=nil, &block)
       raise(Error, "must provide either mod or block, not both") if mod && block
-      mod = Dataset::DatasetModule.new(&block) if block
+      mod = Sequel.set_temp_name(Dataset::DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"} if block
       if @dataset_modules.empty?
        @dataset_modules = [mod]
-       @dataset_class = Class.new(@dataset_class)
+       @dataset_class = Sequel.set_temp_name(Class.new(@dataset_class)){"Sequel::Dataset::_Subclass"}
       else
        @dataset_modules << mod
       end

data/lib/sequel/database/misc.rb

@@ -116,6 +116,10 @@ module Sequel
     # :after_connect :: A callable object called after each new connection is made, with the
     #                   connection object (and server argument if the callable accepts 2 arguments),
     #                   useful for customizations that you want to apply to all connections.
+    # :compare_connections_by_identity :: Whether to use compare_by_identity on hashes that use
+    #                                     connection objects as keys. Defaults to true. This should only
+    #                                     be set to false to work around bugs in libraries or
+    #                                     ruby implementations.
     # :before_preconnect :: Callable that runs after extensions from :preconnect_extensions are loaded,
     #                       but before any connections are created.
     # :cache_schema :: Whether schema should be cached for this Database instance
@@ -165,7 +169,7 @@ module Sequel
       @schemas = {}
       @prepared_statements = {}
       @transactions = {}
-      @transactions.compare_by_identity
+      @transactions.compare_by_identity if typecast_value_boolean(@opts.fetch(:compare_connections_by_identity, true))
       @symbol_literal_cache = {}
 
       @timezone = nil

data/lib/sequel/database/schema_generator.rb

@@ -430,6 +430,10 @@ module Sequel
       #   add_unique_constraint(:name, name: :unique_name) # ADD CONSTRAINT unique_name UNIQUE (name)
       #
       # Supports the same :deferrable option as CreateTableGenerator#column.
+      #
+      # PostgreSQL specific options:
+      #
+      # :using_index :: Use the USING INDEX clause to specify an existing unique index
       def add_unique_constraint(columns, opts = OPTS)
         @operations << {:op => :add_constraint, :type => :unique, :columns => Array(columns)}.merge!(opts)
         nil
@@ -483,6 +487,10 @@ module Sequel
       #
       #   add_primary_key(:id) # ADD COLUMN id serial PRIMARY KEY
       #   add_primary_key([:artist_id, :name]) # ADD PRIMARY KEY (artist_id, name)
+      #
+      # PostgreSQL specific options:
+      #
+      # :using_index :: Use the USING INDEX clause to specify an existing unique index
       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/dataset/deprecated_singleton_class_methods.rb

@@ -19,7 +19,7 @@ module Sequel
       def with_extend(*mods, &block)
         c = _clone(:freeze=>false)
         c.extend(*mods) unless mods.empty?
-        c.extend(DatasetModule.new(&block)) if block
+        c.extend(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"}) if block
         c.freeze
       end
 

data/lib/sequel/dataset/prepared_statements.rb

@@ -20,7 +20,8 @@ module Sequel
     def self.prepared_statements_module(code, mods, meths=DEFAULT_PREPARED_STATEMENT_MODULE_METHODS, &block)
       code = PREPARED_STATEMENT_MODULE_CODE[code] || code
 
-      Module.new do
+      Module.new do 
+        Sequel.set_temp_name(self){"Sequel::Dataset::_PreparedStatementsModule(#{block.source_location.join(':') if block})"}
         Array(mods).each do |mod|
           include mod
         end

data/lib/sequel/dataset/query.rb

@@ -1238,9 +1238,9 @@ module Sequel
       # Note that like Object#extend, when multiple modules are provided
       # as arguments the subclass includes the modules in reverse order.
       def with_extend(*mods, &block)
-        c = Class.new(self.class)
+        c = Sequel.set_temp_name(Class.new(self.class)){"Sequel::Dataset::_Subclass"}
         c.include(*mods) unless mods.empty?
-        c.include(DatasetModule.new(&block)) if block
+        c.include(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"}) if block
         o = c.freeze.allocate
         o.instance_variable_set(:@db, @db)
         o.instance_variable_set(:@opts, @opts)

data/lib/sequel/extensions/connection_validator.rb

@@ -105,18 +105,23 @@ module Sequel
       1.times do
         if (conn = super) &&
            (timer = sync{@connection_timestamps.delete(conn)}) &&
-           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout &&
-           !db.valid_connection?(conn)
+           Sequel.elapsed_seconds_since(timer) > @connection_validation_timeout
 
-          case pool_type
-          when :sharded_threaded, :sharded_timed_queue
-            sync{@allocated[a.last].delete(Sequel.current)}
-          else
-            sync{@allocated.delete(Sequel.current)}
-          end
+          begin
+            valid = db.valid_connection?(conn)
+          ensure
+            unless valid
+              case pool_type
+              when :sharded_threaded, :sharded_timed_queue
+                sync{@allocated[a.last].delete(Sequel.current)}
+              else
+                sync{@allocated.delete(Sequel.current)}
+              end
 
-          disconnect_connection(conn)
-          redo
+              disconnect_connection(conn)
+              redo if valid == false
+            end
+          end
         end
       end
 

data/lib/sequel/extensions/pg_auto_parameterize_in_array.rb

@@ -27,9 +27,14 @@
 # treating strings as text can break programs, since the type for
 # literal strings in PostgreSQL is +unknown+, not +text+.
 #
-# The conversion is only done for single dimensional arrays that have more
-# than two elements, where all elements are of the same class (other than
-# nil values).
+# The conversion is only done for single dimensional arrays that have two or
+# more elements, where all elements are of the same class (other than
+# +nil+ values).  You can also do the conversion for arrays of 1 element by setting
+# <tt>pg_auto_parameterize_min_array_size: 1</tt> Database option.  This makes
+# finding cases that need special handling easier, but it doesn't match
+# how PostgreSQL internally converts the expression (PostgreSQL converts
+# <tt>IN (single_value)</tt> to <tt>= single_value</tt>, not
+# <tt>= ANY(ARRAY[single_value])</tt>).
 #
 # Related module: Sequel::Postgres::AutoParameterizeInArray
 
@@ -68,7 +73,7 @@ module Sequel
       # The bound variable type string to use for the bound variable array.
       # Returns nil if a bound variable should not be used for the array.
       def _bound_variable_type_for_array(r)
-        return unless Array === r && r.size > 1
+        return unless Array === r && r.size >= (db.typecast_value(:integer, db.opts[:pg_auto_parameterize_min_array_size]) || 2)
         classes = r.map(&:class)
         classes.uniq!
         classes.delete(NilClass)

data/lib/sequel/extensions/pg_enum.rb

@@ -149,12 +149,12 @@ module Sequel
             from(:pg_type).
             where(:oid=>enum_labels.keys).
             exclude(:typarray=>0).
-            select_map([:typname, Sequel.cast(:typarray, Integer).as(:v)])
+            select_map([:typname, Sequel.cast(:typarray, Integer).as(:v), Sequel.cast(:oid, Integer).as(:sv)])
 
           existing_oids = conversion_procs.keys
-          array_types.each do |name, oid|
+          array_types.each do |name, oid, scalar_oid|
             next if existing_oids.include?(oid)
-            register_array_type(name, :oid=>oid)
+            register_array_type(name, :oid=>oid, :scalar_oid=>scalar_oid)
           end
         end
 

data/lib/sequel/extensions/pg_row.rb

@@ -113,6 +113,7 @@ module Sequel
         # automatically casted to the database type when literalizing.
         def self.subclass(db_type)
           Class.new(self) do
+            Sequel.set_temp_name(self){"Sequel::Postgres::PGRow::ArrayRow::_Subclass(#{db_type})"}
             @db_type = db_type
           end
         end
@@ -170,6 +171,7 @@ module Sequel
         # type and columns.
         def self.subclass(db_type, columns)
           Class.new(self) do
+            Sequel.set_temp_name(self){"Sequel::Postgres::PGRow::HashRow::_Subclass(#{db_type})"}
             @db_type = db_type
             @columns = columns
           end
@@ -391,7 +393,7 @@ module Sequel
           db.instance_exec do
             @row_types = {}
             @row_schema_types = {}
-            extend(@row_type_method_module = Module.new)
+            extend(@row_type_method_module = Sequel.set_temp_name(Module.new){"Sequel::Postgres::PGRow::DatabaseMethods::_RowTypeMethodModule"})
             add_conversion_proc(2249, PGRow::Parser.new(:converter=>PGRow::ArrayRow))
             if respond_to?(:register_array_type)
               register_array_type('record', :oid=>2287, :scalar_oid=>2249)

data/lib/sequel/extensions/query_blocker.rb

@@ -0,0 +1,172 @@
+# frozen-string-literal: true
+#
+# The query_blocker extension adds Database#block_queries.
+# Inside the block passed to #block_queries, any attempts to
+# execute a query/statement on the database will raise a
+# Sequel::QueryBlocker::BlockedQuery exception.
+#
+#   DB.extension :query_blocker
+#   DB.block_queries do
+#     ds = DB[:table]          # No exception
+#     ds = ds.where(column: 1) # No exception
+#     ds.all                   # Exception raised
+#   end
+#
+# To handle concurrency, you can pass a :scope option:
+#
+#   # Current Thread
+#   DB.block_queries(scope: :thread){}
+#
+#   # Current Fiber
+#   DB.block_queries(scope: :fiber){}
+#
+#   # Specific Thread
+#   DB.block_queries(scope: Thread.current){}
+#
+#   # Specific Fiber
+#   DB.block_queries(scope: Fiber.current){}
+#
+# Database#block_queries is useful for blocking queries inside
+# the block.  However, there may be cases where you want to
+# allow queries in specific places inside a block_queries block.
+# You can use Database#allow_queries for that:
+#
+#   DB.block_queries do
+#     DB.allow_queries do
+#       DB[:table].all           # Query allowed
+#     end
+#
+#     DB[:table].all           # Exception raised
+#   end
+#
+# When mixing block_queries and allow_queries with scopes, the
+# narrowest scope has priority.  So if you are blocking with
+# :thread scope, and allowing with :fiber scope, queries in the
+# current fiber will be allowed, but queries in different fibers of
+# the current thread will be blocked.
+#
+# Note that this should catch all queries executed through the
+# Database instance.  Whether it catches queries executed directly
+# on a connection object depends on the adapter in use.
+#
+# Related module: Sequel::QueryBlocker
+
+require "fiber"
+
+#
+module Sequel
+  module QueryBlocker
+    # Exception class raised if there is an attempt to execute a 
+    # query/statement on the database inside a block passed to
+    # block_queries.
+    class BlockedQuery < Sequel::Error
+    end
+
+    def self.extended(db)
+      db.instance_exec do
+        @blocked_query_scopes ||= {}
+      end
+    end
+
+    # If checking a connection for validity, and a BlockedQuery exception is
+    # raised, treat it as a valid connection.  You cannot check whether the
+    # connection is valid without issuing a query, and if queries are blocked,
+    # you need to assume it is valid or assume it is not.  Since it most cases
+    # it will be valid, this assumes validity.
+    def valid_connection?(conn)
+      super
+    rescue BlockedQuery
+      true
+    end
+
+    # Check whether queries are blocked before executing them.
+    def log_connection_yield(sql, conn, args=nil)
+      # All database adapters should be calling this method around
+      # query execution (otherwise the queries would not get logged),
+      # ensuring the blocking is checked.  Any database adapter issuing
+      # a query without calling this method is considered buggy.
+      check_blocked_queries!
+      super
+    end
+
+    # Whether queries are currently blocked.
+    def block_queries?
+      b = @blocked_query_scopes
+      b.fetch(Fiber.current) do
+        b.fetch(Thread.current) do
+          b.fetch(:global, false)
+        end
+      end
+    end
+
+    # Allow queries inside the block.  Only useful if they are already blocked
+    # for the same scope. Useful for blocking queries generally, and only allowing
+    # them in specific places.  Takes the same :scope option as #block_queries.
+    def allow_queries(opts=OPTS, &block)
+      _allow_or_block_queries(false, opts, &block)
+    end
+
+    # Reject (raise an BlockedQuery exception) if there is an attempt to execute
+    # a query/statement inside the block.
+    #
+    # The :scope option indicates which queries are rejected inside the block:
+    #
+    # :global :: This is the default, and rejects all queries.
+    # :thread :: Reject all queries in the current thread.
+    # :fiber :: Reject all queries in the current fiber.
+    # Thread :: Reject all queries in the given thread.
+    # Fiber :: Reject all queries in the given fiber.
+    def block_queries(opts=OPTS, &block)
+      _allow_or_block_queries(true, opts, &block)
+    end
+    
+    private
+
+    # Internals of block_queries and allow_queries.
+    def _allow_or_block_queries(value, opts)
+      scope = query_blocker_scope(opts)
+      prev_value = nil
+      scopes = @blocked_query_scopes
+
+      begin
+        Sequel.synchronize do
+          prev_value = scopes[scope]
+          scopes[scope] = value
+        end
+
+        yield
+      ensure
+        Sequel.synchronize do
+          if prev_value.nil?
+            scopes.delete(scope)
+          else
+            scopes[scope] = prev_value
+          end
+        end
+      end
+    end
+
+    # The scope for the query block, either :global, or a Thread or Fiber instance.
+    def query_blocker_scope(opts)
+      case scope = opts[:scope]
+      when nil
+        :global
+      when :global, Thread, Fiber
+        scope
+      when :thread
+        Thread.current
+      when :fiber
+        Fiber.current
+      else
+        raise Sequel::Error, "invalid scope given to block_queries: #{scope.inspect}"
+      end
+    end
+
+    # Raise a BlockQuery exception if queries are currently blocked.
+    def check_blocked_queries!
+      raise BlockedQuery, "cannot execute query inside a block_queries block" if block_queries?
+    end
+  end
+
+  Database.register_extension(:query_blocker, QueryBlocker)
+end

data/lib/sequel/extensions/virtual_row_method_block.rb

@@ -14,6 +14,7 @@ module Sequel
   module SQL
     class VirtualRow < BasicObject
       include(Module.new do
+        Sequel.set_temp_name(self){"Sequel::SQL:VirtualRow::_MethodBlockMethodMissing"}
         # Handle blocks passed to methods and change the behavior.
         def method_missing(m, *args, &block)
           if block

data/lib/sequel/model/associations.rb

@@ -693,6 +693,9 @@ module Sequel
 
         # The predicate condition to use for the eager_loader.
         def eager_loading_predicate_condition(keys)
+          if transform = self[:eager_loading_predicate_transform]
+            keys = transform.call(keys, self)
+          end
           {predicate_key=>keys}
         end
 
@@ -759,7 +762,15 @@ module Sequel
         def placeholder_eager_loader
           cached_fetch(:placeholder_eager_loader) do
             eager_loading_dataset.placeholder_literalizer_loader do |pl, ds|
-              apply_eager_limit_strategy(ds.where(predicate_key=>pl.arg), eager_limit_strategy)
+              arg = pl.arg
+
+              if transform = self[:eager_loading_predicate_transform]
+                arg = arg.transform do |v|
+                  transform.call(v, self)
+                end
+              end
+
+              apply_eager_limit_strategy(ds.where(predicate_key=>arg), eager_limit_strategy)
             end
           end
         end
@@ -1707,6 +1718,9 @@ module Sequel
         #                  record should be populated.
         # :eager_loader_key :: A symbol for the key column to use to populate the key_hash
         #                      for the eager loader.  Can be set to nil to not populate the key_hash.
+        # :eager_loading_predicate_transform :: A callable object with which to transform the predicate key values used
+        #                                       when eager loading. Called with two arguments, the array of predicate key
+        #                                       values, and a the reflection for the association being eager loaded.
         # :extend :: A module or array of modules to extend the dataset with.
         # :filter_limit_strategy :: Determines the strategy used for enforcing limits and offsets when filtering by
         #                           limited associations.  Possible options are :window_function, :distinct_on, or
@@ -1769,6 +1783,9 @@ module Sequel
         #            Set to nil to not define a setter method for the association.
         # :subqueries_per_union :: The number of subqueries to use in each UNION query, for eager
         #                          loading limited associations using the default :union strategy.
+        # :use_placeholder_loader :: Whether to use a placeholder loader when eager loading the
+        #                            association.  Can be set to false to disable the use of a placeholder
+        #                            loader if one would be used by default.
         # :validate :: Set to false to not validate when implicitly saving any associated object.
         # === :many_to_one
         # :key :: foreign key in current model's table that references
@@ -1891,7 +1908,7 @@ module Sequel
             raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
           end
 
-          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph]
+          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph] unless opts.include?(:use_placeholder_loader)
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)

data/lib/sequel/model/base.rb

@@ -184,7 +184,7 @@ module Sequel
           end
         end
 
-        klass = Class.new(self)
+        klass = Sequel.set_temp_name(Class.new(self)){"Sequel::_Model(#{source.inspect})"}
 
         if source.is_a?(::Sequel::Database)
           klass.db = source
@@ -768,7 +768,8 @@ module Sequel
       # default behavior.
       def dataset_methods_module
         return @dataset_methods_module if defined?(@dataset_methods_module)
-        Sequel.synchronize{@dataset_methods_module ||= Module.new}
+        mod_name = "#{name}::@dataset_methods_module"
+        Sequel.synchronize{@dataset_methods_module ||= Sequel.set_temp_name(Module.new){mod_name}}
         extend(@dataset_methods_module)
         @dataset_methods_module
       end
@@ -956,7 +957,10 @@ END
       # Module that the class includes that holds methods the class adds for column accessors and
       # associations so that the methods can be overridden with +super+.
       def overridable_methods_module
-        include(@overridable_methods_module = Module.new) unless @overridable_methods_module
+        return @overridable_methods_module if defined?(@overridable_methods_module)
+        mod_name = "#{name}::@overridable_methods_module"
+        Sequel.synchronize{@overridable_methods_module ||= Sequel.set_temp_name(Module.new){mod_name}}
+        include(@overridable_methods_module)
         @overridable_methods_module
       end
       
@@ -1610,7 +1614,7 @@ END
         @skip_validation_on_next_save = true
       end
 
-      # Returns (naked) dataset that should return only this instance.
+      # Returns naked dataset that should return only the row related to this instance.
       #
       #   Artist[1].this
       #   # SELECT * FROM artists WHERE (id = 1) LIMIT 1

data/lib/sequel/plugins/composition.rb

@@ -61,7 +61,7 @@ module Sequel
       def self.apply(model)
         model.instance_exec do
           @compositions = {}
-          include(@composition_module ||= Module.new)
+          include(@composition_module ||= Sequel.set_temp_name(Module.new){"#{name}::@composition_module"})
         end
       end
 

data/lib/sequel/plugins/enum.rb

@@ -80,7 +80,7 @@ module Sequel
           inverted = values.invert.freeze
 
           unless @enum_methods
-            @enum_methods = Module.new
+            @enum_methods = Sequel.set_temp_name(Module.new){"#{name}::@enum_methods"}
             include @enum_methods
           end
 

data/lib/sequel/plugins/inverted_subsets.rb

@@ -32,6 +32,7 @@ module Sequel
       def self.apply(model, &block)
         model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
+            Sequel.set_temp_name(self){"#{model.name}::@dataset_module_class(InvertedSubsets)"}
             include DatasetModuleMethods
             if block
               define_method(:inverted_subset_name, &block)

data/lib/sequel/plugins/lazy_attributes.rb

@@ -64,7 +64,7 @@ module Sequel
         # :dataset :: The base dataset to use for the lazy attribute lookup
         # :table :: The table name to use to qualify the attribute and primary key columns.
         def define_lazy_attribute_getter(a, opts=OPTS)
-          include(@lazy_attributes_module ||= Module.new) unless @lazy_attributes_module
+          include(@lazy_attributes_module ||= Sequel.set_temp_name(Module.new){"#{name}::@lazy_attributes_module"}) unless @lazy_attributes_module
           @lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.has_key?(a) && !new?

data/lib/sequel/plugins/nested_attributes.rb

@@ -129,7 +129,7 @@ module Sequel
         #
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
-          include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
+          include(@nested_attributes_module ||= Sequel.set_temp_name(Module.new){"#{name}::@nested_attributes_module"}) unless @nested_attributes_module
           opts = associations.last.is_a?(Hash) ? associations.pop : OPTS
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|

data/lib/sequel/plugins/pg_eager_any_typed_array.rb

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The pg_eager_any_typed_array plugin automatically converts
+    # the predicate expressions used for eager loading from:
+    #
+    #   table.column IN (value_list)
+    #
+    # to:
+    #
+    #   table.column = ANY(array_expr::type[])
+    #
+    # This makes it easier to use the pg_auto_parameterize_in_array
+    # extension with the :treat_string_list_as_text_array option,
+    # when using foreign keys with non-text database types that are represented
+    # by Ruby strings, such as enum and uuid types.
+    #
+    # Most association types that ship with Sequel have their predicate
+    # expressions converted by this plugin.  Here are the exceptions:
+    #
+    # * associations using composite predicate keys
+    # * many_to_pg_array associations
+    # * many_to_many/one_through_one associations using :join_table_db option
+    # * many_through_many/one_through_many associations using
+    #   :separate_table_per_query option
+    #
+    # To avoid predicate conversion for particular associations, set the
+    # :eager_loading_predicate_transform association option to nil/false.
+    #
+    # This plugin loads the pg_array extension into the model's Database.
+    module PgEagerAnyTypedArray
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
+      module ClassMethods
+        TRANSFORM = proc do |values, ref|
+          type = ref.send(:cached_fetch, :_pg_eager_any_typed_array_type) do
+            key = ref.predicate_key
+            next if key.is_a?(Array)
+
+            while key.is_a?(SQL::QualifiedIdentifier)
+              key = key.column
+            end
+
+            # :nocov:
+            # many_to_pg_array association type does not need changes, as it
+            # already converts the values to a typed postgres array, it does
+            # not call the code that uses :eager_loading_predicate_transform.
+            #
+            # No association type that ships with Sequel can reach this code
+            # unless it is one of these types, but external association types
+            # could potentially reach it.
+            sch = case ref[:type]
+            # :nocov:
+            when :many_to_one, :one_to_one, :one_to_many, :pg_array_to_many
+              ref.associated_class.db_schema
+            when :many_to_many, :one_through_one
+              # Not compatible with the :join_table_db option, but that option
+              # does not call into this code.
+              Hash[ref.associated_class.db.schema(ref.join_table_source)]
+            when :many_through_many, :one_through_many
+              # Not compatible with the :separate_query_per_table option, but
+              # that option does not call into this code.
+              Hash[ref.associated_class.db.schema(ref[:through][0][:table])]
+            end
+
+            if sch && (sch = sch[key])
+              sch[:db_type]
+            end
+          end
+
+          if type
+            Sequel.function(:ANY, Sequel.pg_array(values, type))
+          else
+            values
+          end
+        end
+
+        # Set the :eager_loading_predicate_transform option if not already set
+        def associate(type, name, opts = OPTS, &block)
+          res = super
+
+          unless res.has_key?(:eager_loading_predicate_transform)
+            res[:eager_loading_predicate_transform] = TRANSFORM
+          end
+
+          res
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/rcte_tree.rb

@@ -81,7 +81,7 @@ module Sequel
 
         opts = opts.dup
         opts[:class] = model
-        opts[:methods_module] = Module.new
+        opts[:methods_module] = Sequel.set_temp_name(Module.new){"#{model.name}::_rcte_tree[:methods_module]"}
         opts[:union_all] = opts[:union_all].nil? ? true : opts[:union_all]
         model.send(:include, opts[:methods_module])
         

data/lib/sequel/plugins/serialization.rb

@@ -146,7 +146,7 @@ module Sequel
         # Add serializated attribute acessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
-          include(@serialization_module ||= Module.new) unless @serialization_module
+          include(@serialization_module ||= Sequel.set_temp_name(Module.new){"#{name}::@serialization_module"}) unless @serialization_module
           @serialization_module.class_eval do
             columns.each do |column|
               m.serialization_map[column] = serializer

data/lib/sequel/plugins/sql_comments.rb

@@ -40,7 +40,8 @@ module Sequel
     #   Album.sql_comments_dataset_methods :to_csv # csv_serializer plugin
     #
     # In order for the sql_comments plugin to work, the sql_comments
-    # Database extension must be loaded into the model's database.
+    # Database extension must be loaded into the model's database, so
+    # loading the plugin does this automatically.
     #
     # Note that in order to make sure SQL comments are included, some
     # optimizations are disabled if this plugin is loaded.
@@ -67,6 +68,10 @@ module Sequel
         # :nocov:
       end
 
+      def self.apply(model)
+        model.db.extension(:sql_comments)
+      end
+
       def self.configure(model)
         model.send(:reset_fast_pk_lookup_sql)
       end
@@ -85,7 +90,7 @@ module Sequel
         # Use automatic SQL comments for the given dataset methods.
         def sql_comments_dataset_methods(*meths)
           unless @_sql_comments_dataset_module
-            dataset_module(@_sql_comments_dataset_module = Module.new)
+            dataset_module(@_sql_comments_dataset_module = Sequel.set_temp_name(Module.new){"#{name}::@_sql_comments_dataset_module"})
           end
           _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
         end

data/lib/sequel/plugins/subset_conditions.rb

@@ -48,6 +48,7 @@ module Sequel
       def self.apply(model, &block)
         model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
+            Sequel.set_temp_name(self){"#{model.name}::@dataset_module_class(SubsetConditions)"}
             include DatasetModuleMethods
           end
         end

data/lib/sequel/plugins/subset_static_cache.rb

@@ -99,7 +99,8 @@ module Sequel
           # it before calling creating this module.
           dataset_methods_module
 
-          Sequel.synchronize{@subset_static_cache_module ||= Module.new}
+          mod_name = "#{name}::@subset_static_cache_module"
+          Sequel.synchronize{@subset_static_cache_module ||= Sequel.set_temp_name(Module.new){mod_name}}
           extend(@subset_static_cache_module)
           @subset_static_cache_module
         end

data/lib/sequel/sql.rb

@@ -1127,7 +1127,13 @@ module Sequel
         when DelayedEvaluation
           Sequel.delay{|ds| from_value_pair(l, r.call(ds))}
         when Dataset::PlaceholderLiteralizer::Argument
-          r.transform{|v| from_value_pair(l, v)}
+          prev_transform = r.instance_variable_get(:@transformer)
+          r.transform do |v|
+            if prev_transform
+              v = prev_transform.call(v)
+            end
+            from_value_pair(l, v)
+          end
         else
           new(:'=', l, r)
         end
@@ -1915,6 +1921,7 @@ module Sequel
       end
 
       m = Module.new do
+        Sequel.set_temp_name(Module.new){"Sequel::SQL::VirtualRow::_BaseMethodMissing"}
         # Return an +Identifier+, +QualifiedIdentifier+, or +Function+, depending
         # on arguments and whether a block is provided.  Does not currently call the block.
         # See the class level documentation.

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.88.0
+  version: 5.90.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-01-01 00:00:00.000000000 Z
+date: 2025-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -273,6 +273,7 @@ files:
 - lib/sequel/extensions/pretty_table.rb
 - lib/sequel/extensions/provenance.rb
 - lib/sequel/extensions/query.rb
+- lib/sequel/extensions/query_blocker.rb
 - lib/sequel/extensions/round_timestamps.rb
 - lib/sequel/extensions/run_transaction_hooks.rb
 - lib/sequel/extensions/s.rb
@@ -370,6 +371,7 @@ files:
 - lib/sequel/plugins/paged_operations.rb
 - lib/sequel/plugins/pg_array_associations.rb
 - lib/sequel/plugins/pg_auto_constraint_validations.rb
+- lib/sequel/plugins/pg_eager_any_typed_array.rb
 - lib/sequel/plugins/pg_row.rb
 - lib/sequel/plugins/pg_xmin_optimistic_locking.rb
 - lib/sequel/plugins/prepared_statements.rb