sequel 5.87.0 → 5.89.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8be61078e55201001f1041d09be334411bfaef071e6dbeb3c9082c21b0e70dce
-  data.tar.gz: c877f3832d2ef28b14d7037e6bbf7bbe90d2d6f6391736bc3b9e6bdc142b5ba5
+  metadata.gz: 8248e272e580f0e89e508e2aa97ebea83ac083b3f1bd347fc9d34700fd98ae42
+  data.tar.gz: a74658ae42f7e087a541056d5f0cac2db4cc67b11ca56367b2bea309e502df49
 SHA512:
-  metadata.gz: 7b032d7f8987e0727cc79b98f7f6d5319cd1dc13657c3a2ebc16bff4276d26eb368f1a498d51e27df0aea89184d0b811f6a05355cf3f7a400b45cd8707061f63
-  data.tar.gz: f2a1326e3635a7840e220b368459407409391507a3e87cb85ac01f4360d5762a9bdf15ee350032875f9c6d202f03b868fd6c7af43e72bf80cca007edd34cc14e
+  metadata.gz: c2875a0f53a46efa87b3380b3fe2c1bbae46542076e3e5615ddcd53b55ac6dfefa53fc828ec4f1277df85a7852eb0e2934377d074e58a6410837138ed2e2a7db
+  data.tar.gz: 8c1a3591085be13aef51f3bc63f0407249858c57e91c3f314b92d929d362c4aafd0b801ee52ca0f96acb18f6fa133d33c4532b5a0fc13fc61e599ba3e05f4e6c

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
 
@@ -2388,6 +2399,25 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
+      # Handle column aliases containing data types, useful for selecting from functions
+      # that return the record data type.
+      def derived_column_list_sql_append(sql, column_aliases)
+        c = false
+        comma = ', '
+        column_aliases.each do |a|
+          sql << comma if c
+          if a.is_a?(Array)
+            raise Error, "column aliases specified as arrays must have only 2 elements, the first is alias name and the second is data type" unless a.length == 2
+            a, type = a
+            identifier_append(sql, a)
+            sql << " " << db.cast_type_literal(type).to_s
+          else
+            identifier_append(sql, a)
+          end
+          c ||= true
+        end
+      end
+    
       # Add ON CONFLICT clause if it should be used
       def insert_conflict_sql(sql)
         if opts = @opts[:insert_conflict]

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/dataset/sql.rb

@@ -1032,7 +1032,7 @@ module Sequel
       if column_aliases
         raise Error, "#{db.database_type} does not support derived column lists" unless supports_derived_column_lists?
         sql << '('
-        identifier_list_append(sql, column_aliases)
+        derived_column_list_sql_append(sql, column_aliases)
         sql << ')'
       end
     end
@@ -1165,6 +1165,11 @@ module Sequel
       end
     end
 
+    # Append the column aliases to the SQL.
+    def derived_column_list_sql_append(sql, column_aliases)
+      identifier_list_append(sql, column_aliases)
+    end
+    
     # Disable caching of SQL for the current dataset
     def disable_sql_caching!
       cache_set(:_no_cache_sql, true)

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
+            end
+          end
         end
       end
 

data/lib/sequel/extensions/migration.rb

@@ -223,7 +223,7 @@ module Sequel
       @actions << [:drop_join_table, *args]
     end
 
-    def create_table(name, opts=OPTS)
+    def create_table(name, opts=OPTS, &_)
       @actions << [:drop_table, name, opts]
     end
 
@@ -371,7 +371,7 @@ module Sequel
   #
   # Part of the +migration+ extension.
   class Migrator
-    MIGRATION_FILE_PATTERN = /\A(\d+)_.+\.rb\z/i.freeze
+    MIGRATION_FILE_PATTERN = /\A(\d+)_(.+)\.rb\z/i.freeze
 
     # Mutex used around migration file loading
     MUTEX = Mutex.new
@@ -791,7 +791,23 @@ module Sequel
         next unless MIGRATION_FILE_PATTERN.match(file)
         files << File.join(directory, file)
       end
-      files.sort_by{|f| MIGRATION_FILE_PATTERN.match(File.basename(f))[1].to_i}
+      files.sort! do |a, b|
+        a_ver, a_name = split_migration_filename(a)
+        b_ver, b_name = split_migration_filename(b)
+        x = a_ver <=> b_ver
+        if x.zero?
+          x = a_name <=> b_name
+        end
+        x
+      end
+      files
+    end
+
+    # Return an integer and name (without extension) for the given path.
+    def split_migration_filename(path)
+      version, name = MIGRATION_FILE_PATTERN.match(File.basename(path)).captures
+      version = version.to_i
+      [version, name]
     end
     
     # Returns tuples of migration, filename, and direction

data/lib/sequel/extensions/null_dataset.rb

@@ -63,12 +63,12 @@ module Sequel
       end
 
       # Return self without sending a database query, never yielding.
-      def each
+      def each(&_)
         self
       end
 
       # Return nil without sending a database query, never yielding.
-      def fetch_rows(sql)
+      def fetch_rows(sql, &_)
         nil
       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/string_agg.rb

@@ -173,7 +173,7 @@ module Sequel
       # Return a modified StringAgg that uses distinct expressions
       def distinct
         self.class.new(@expr, @separator) do |sa|
-          sa.instance_variable_set(:@order_expr, @order_expr) if @order_expr
+          sa.instance_variable_set(:@order_expr, @order_expr)
           sa.instance_variable_set(:@distinct, true)
         end
       end
@@ -181,8 +181,8 @@ module Sequel
       # Return a modified StringAgg with the given order
       def order(*o)
         self.class.new(@expr, @separator) do |sa|
-          sa.instance_variable_set(:@distinct, @distinct) if @distinct
           sa.instance_variable_set(:@order_expr, o.empty? ? nil : o.freeze)
+          sa.instance_variable_set(:@distinct, @distinct)
         end
       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/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
@@ -762,22 +762,35 @@ module Sequel
           end
         end
       end
+
+      # Module that the class methods that call dataset methods are kept in.
+      # This allows the methods to be overridden and call super with the
+      # default behavior.
+      def dataset_methods_module
+        return @dataset_methods_module if defined?(@dataset_methods_module)
+        Sequel.synchronize{@dataset_methods_module ||= Sequel.set_temp_name(Module.new){"#{name}::@dataset_methods_module"}}
+        extend(@dataset_methods_module)
+        @dataset_methods_module
+      end
   
-      # Define a model method that calls the dataset method with the same name,
-      # only used for methods with names that can't be represented directly in
-      # ruby code.
+      # Define a model method that calls the dataset method with the same name.
       def def_model_dataset_method(meth)
         return if respond_to?(meth, true)
 
+        mod = dataset_methods_module
+
         if meth.to_s =~ /\A[A-Za-z_][A-Za-z0-9_]*\z/
-          instance_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+          mod.module_eval(<<END, __FILE__, __LINE__ + 1)
+def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end
+ruby2_keywords :#{meth} if respond_to?(:ruby2_keywords, true)
+END
         else
-          define_singleton_method(meth){|*args, &block| dataset.public_send(meth, *args, &block)}
+          mod.send(:define_method, meth){|*args, &block| dataset.public_send(meth, *args, &block)}
+          # :nocov:
+          mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
         end
-        singleton_class.send(:alias_method, meth, meth)
-        # :nocov:
-        singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
-        # :nocov:
+        mod.send(:alias_method, meth, meth)
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -943,7 +956,7 @@ module Sequel
       # 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
+        include(@overridable_methods_module = Sequel.set_temp_name(Module.new){"#{name}::@overridable_methods_module"}) unless @overridable_methods_module
         @overridable_methods_module
       end
       

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/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

@@ -37,7 +37,8 @@ module Sequel
     #
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse, :reverse.to_proc, :reverse.to_proc)
+    #   require 'base64'
+    #   Sequel::Plugins::Serialization.register_format(:base64, Base64.method(:encode64), Base64.method(:decode64))
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -48,10 +49,10 @@ module Sequel
     #     serialize_attributes :marshal, :permissions
     #
     #     # Use custom registered serialization format just like built-in format
-    #     serialize_attributes :reverse, :password
+    #     serialize_attributes :base64, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [:reverse.to_proc, :reverse.to_proc], :password
+    #     serialize_attributes [ Base64.method(:encode64), Base64.method(:decode64)], :password
     #   end
     #   user = User.create
     #   user.permissions = {global: 'read-only'}
@@ -123,7 +124,12 @@ module Sequel
         end
         
         # Create instance level reader that deserializes column values on request,
-        # and instance level writer that stores new deserialized values.
+        # and instance level writer that stores new deserialized values. If +format+
+        # is a symbol, it should correspond to a previously-registered format using +register_format+.
+        # Otherwise, +format+ is expected to be a 2-element array of callables,
+        # with the first element being the serializer, used to convert the value used by the application
+        # to the value that will be stored in the database, and the second element being the deserializer,
+        # used to convert the value stored the database to the value used by the application.
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
             unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
@@ -140,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

@@ -85,7 +85,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/static_cache_cache.rb

@@ -2,11 +2,11 @@
 
 module Sequel
   module Plugins
-    # The static_cache_cache plugin allows for caching the row content for subclasses
-    # that use the static cache plugin (or just the current class).  Using this plugin
-    # can avoid the need to query the database every time loading the plugin into a
-    # model, which can save time when you have a lot of models using the static_cache
-    # plugin.
+    # The static_cache_cache plugin allows for caching the row content for the current
+    # class and subclasses that use the static_cache or subset_static_cache plugins.
+    # Using this plugin can avoid the need to query the database every time loading
+    # the static_cache plugin into a model (static_cache plugin) or using the
+    # cache_subset method (subset_static_cache plugin).
     #
     # Usage:
     #
@@ -26,11 +26,7 @@ module Sequel
       module ClassMethods
         # Dump the in-memory cached rows to the cache file.
         def dump_static_cache_cache
-          static_cache_cache = {}
-          @static_cache_cache.sort.each do |k, v|
-            static_cache_cache[k] = v
-          end
-          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(static_cache_cache))}
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(sort_static_cache_hash(@static_cache_cache)))}
           nil
         end
 
@@ -38,16 +34,57 @@ module Sequel
 
         private
 
+        # Sort the given static cache hash in a deterministic way, so that 
+        # the same static cache values will result in the same marshal file.
+        def sort_static_cache_hash(cache)
+          cache = cache.sort do |a, b|
+            a, = a
+            b, = b
+            if a.is_a?(Array)
+              if b.is_a?(Array)
+                a_name, a_meth = a
+                b_name, b_meth = b
+                x = a_name <=> b_name
+                if x.zero?
+                  x = a_meth <=> b_meth
+                end
+                x
+              else
+                1
+              end
+            elsif b.is_a?(Array)
+              -1
+            else
+              a <=> b
+            end
+          end
+          Hash[cache]
+        end
+
         # Load the rows for the model from the cache if available.
         # If not available, load the rows from the database, and
         # then update the cache with the raw rows.
         def load_static_cache_rows
-          if rows = Sequel.synchronize{@static_cache_cache[name]}
+          _load_static_cache_rows(dataset, name)
+        end
+
+        # Load the rows for the subset from the cache if available.
+        # If not available, load the rows from the database, and
+        # then update the cache with the raw rows.
+        def load_subset_static_cache_rows(ds, meth)
+          _load_static_cache_rows(ds, [name, meth].freeze)
+        end
+
+        # Check the cache first for the key, and return rows without a database
+        # query if present.  Otherwise, get all records in the provided dataset,
+        # and update the cache with them.
+        def _load_static_cache_rows(ds, key)
+          if rows = Sequel.synchronize{@static_cache_cache[key]}
             rows.map{|row| call(row)}.freeze
           else
-            rows = dataset.all.freeze
+            rows = ds.all.freeze
             raw_rows = rows.map(&:values)
-            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            Sequel.synchronize{@static_cache_cache[key] = raw_rows}
             rows
           end
         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

@@ -0,0 +1,262 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The subset_static_cache plugin is designed for model subsets that are not modified at all
+    # in production use cases, or at least where modifications to them would usually
+    # coincide with an application restart.  When caching a model subset, it 
+    # retrieves all rows in the database and statically caches a ruby array and hash
+    # keyed on primary key containing all of the model instances.  All of these cached
+    # instances are frozen so they won't be modified unexpectedly.
+    #
+    # With the following code:
+    #
+    #   class StatusType < Sequel::Model
+    #     dataset_module do
+    #       where :available, hidden: false
+    #     end
+    #     cache_subset :available
+    #   end
+    #   
+    # The following methods will use the cache and not issue a database query:
+    #
+    # * StatusType.available.with_pk
+    # * StatusType.available.all
+    # * StatusType.available.each
+    # * StatusType.available.first (without block, only supporting no arguments or single integer argument)
+    # * StatusType.available.count (without an argument or block)
+    # * StatusType.available.map
+    # * StatusType.available.as_hash
+    # * StatusType.available.to_hash
+    # * StatusType.available.to_hash_groups
+    #
+    # The cache is not used if you chain methods before or after calling the cached
+    # method, as doing so would not be safe:
+    #
+    #   StatusType.where{number > 1}.available.all 
+    #   StatusType.available.where{number > 1}.all
+    #
+    # The cache is also not used if you change the class's dataset after caching
+    # the subset, or in subclasses of the model.
+    #
+    # You should not modify any row that is statically cached when using this plugin,
+    # as otherwise you will get different results for cached and uncached method
+    # calls.
+    module SubsetStaticCache
+      def self.configure(model)
+        model.class_exec do
+          @subset_static_caches ||= ({}.compare_by_identity)
+        end
+      end
+
+      module ClassMethods
+        # Cache the given subset statically, so that calling the subset method on
+        # the model will return a dataset that will return cached results instead
+        # of issuing database queries (assuming the cache has the necessary
+        # information).
+        #
+        # The model must already respond to the given method before cache_subset
+        # is called.
+        def cache_subset(meth)
+          ds = send(meth).with_extend(CachedDatasetMethods)
+          cache = ds.instance_variable_get(:@cache)
+
+          rows, hash = subset_static_cache_rows(ds, meth)
+          cache[:subset_static_cache_all] = rows
+          cache[:subset_static_cache_map] = hash
+
+          caches = @subset_static_caches
+          caches[meth] = ds
+          model = self
+          subset_static_cache_module.send(:define_method, meth) do
+            if (model == self) && (cached_dataset = caches[meth])
+              cached_dataset
+            else
+              super()
+            end
+          end
+          nil
+        end
+
+        Plugins.after_set_dataset(self, :clear_subset_static_caches)
+        Plugins.inherited_instance_variables(self, :@subset_static_caches=>proc{{}.compare_by_identity})
+
+        private
+
+        # Clear the subset_static_caches.  This is used if the model dataset
+        # changes, to prevent cached values from being used.
+        def clear_subset_static_caches
+          @subset_static_caches.clear
+        end
+
+        # A module for the subset static cache methods, so that you can define
+        # a singleton method in the class with the same name, and call super
+        # to get default behavior.
+        def subset_static_cache_module
+          return @subset_static_cache_module if @subset_static_cache_module
+
+          # Ensure dataset_methods module is defined and class is extended with
+          # it before calling creating this module.
+          dataset_methods_module
+
+          Sequel.synchronize{@subset_static_cache_module ||= Sequel.set_temp_name(Module.new){"#{name}::@subset_static_cache_module"}}
+          extend(@subset_static_cache_module)
+          @subset_static_cache_module
+        end
+         
+        # Return the frozen array and hash used for caching the subset
+        # of the given dataset.
+        def subset_static_cache_rows(ds, meth)
+          all = load_subset_static_cache_rows(ds, meth)
+          h = {}
+          all.each do |o|
+            o.errors.freeze
+            h[o.pk.freeze] = o.freeze
+          end
+          [all, h.freeze]
+        end
+
+        # Return a frozen array for all rows in the dataset.
+        def load_subset_static_cache_rows(ds, meth)
+          ret = super if defined?(super)
+          ret || ds.all.freeze
+        end
+      end
+
+      module CachedDatasetMethods
+        # An array of all of the dataset's instances, without issuing a database
+        # query. If a block is given, yields each instance to the block.
+        def all(&block)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          array = all.dup
+          array.each(&block) if block
+          array
+        end
+
+        # Get the number of records in the cache, without issuing a database query,
+        # if no arguments or block are provided.
+        def count(*a, &block)
+          if a.empty? && !block && (all = @cache[:subset_static_cache_all])
+            all.size
+          else
+            super
+          end
+        end
+
+        # If a block is given, multiple arguments are given, or a single
+        # non-Integer argument is given, performs the default behavior of
+        # issuing a database query.  Otherwise, uses the cached values
+        # to return either the first cached instance (no arguments) or an
+        # array containing the number of instances specified (single integer
+        # argument).
+        def first(*args)
+          if !defined?(yield) && args.length <= 1 && (args.length == 0 || args[0].is_a?(Integer)) && (all = @cache[:subset_static_cache_all])
+            all.first(*args)
+          else
+            super
+          end
+        end
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def with_pk(pk)
+          if cache = @cache[:subset_static_cache_map]
+            cache[pk]
+          else
+            super
+          end
+        end
+
+        # Yield each of the dataset's frozen instances to the block, without issuing a database
+        # query.
+        def each(&block)
+          return super unless all = @cache[:subset_static_cache_all]
+          all.each(&block)
+        end
+
+        # Use the cache instead of a query to get the results.
+        def map(column=nil, &block)
+          return super unless all = @cache[:subset_static_cache_all]
+          if column
+            raise(Error, "Cannot provide both column and block to map") if block
+            if column.is_a?(Array)
+              all.map{|r| r.values.values_at(*column)}
+            else
+              all.map{|r| r[column]}
+            end
+          else
+            all.map(&block)
+          end
+        end
+
+        # Use the cache instead of a query to get the results if possible
+        def as_hash(key_column = nil, value_column = nil, opts = OPTS)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          if key_column.nil? && value_column.nil?
+            if opts[:hash]
+              key_column = model.primary_key
+            else
+              return Hash[@cache[:subset_static_cache_map]]
+            end
+          end
+
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+              else
+                all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
+              else
+                all.each{|r| h[r[key_column]] = r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            all.each{|r| h[r.values.values_at(*key_column)] = r}
+          else
+            all.each{|r| h[r[key_column]] = r}
+          end
+          h
+        end
+
+        # Alias of as_hash for backwards compatibility.
+        def to_hash(*a)
+          as_hash(*a)
+        end
+
+        # Use the cache instead of a query to get the results
+        def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r.values.values_at(*value_column)}
+              else
+                all.each{|r| (h[r[key_column]] ||= []) << r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r[value_column]}
+              else
+                all.each{|r| (h[r[key_column]] ||= []) << r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r}
+          else
+            all.each{|r| (h[r[key_column]] ||= []) << r}
+          end
+          h
+        end
+      end
+    end
+  end
+end

data/lib/sequel/sql.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.87.0
+  version: 5.89.0
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-01 00:00:00.000000000 Z
+date: 2025-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -274,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
@@ -392,6 +392,7 @@ files:
 - lib/sequel/plugins/string_stripper.rb
 - lib/sequel/plugins/subclasses.rb
 - lib/sequel/plugins/subset_conditions.rb
+- lib/sequel/plugins/subset_static_cache.rb
 - lib/sequel/plugins/table_select.rb
 - lib/sequel/plugins/tactical_eager_loading.rb
 - lib/sequel/plugins/throw_failures.rb
@@ -424,7 +425,6 @@ metadata:
   documentation_uri: https://sequel.jeremyevans.net/documentation.html
   mailing_list_uri: https://github.com/jeremyevans/sequel/discussions
   source_code_uri: https://github.com/jeremyevans/sequel
-post_install_message:
 rdoc_options:
 - "--quiet"
 - "--line-numbers"
@@ -446,8 +446,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []