sequel 5.86.0 → 5.88.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2945ab081dad1d3dc6d910e2902247b18750215023e0cfbb5b8f8159811b0d25
-  data.tar.gz: 6b2933b4ac2023a71526a76f40b949e873460e2a7f8aed1524bef47b71f91e79
+  metadata.gz: 6a4a563fddfd5332195e8b9ba2588aef535f27ea0cee15f43afdc877910775ba
+  data.tar.gz: 47cb743d96f031e4fa7e415708473158b2f564b3faa155335a4787e79bce34bd
 SHA512:
-  metadata.gz: 988bfe69b6b4953a7792431e3dd26bcb7ad13f01b8b1dc822fd9d79917608cc2f60bdb7e9a75cfa975bcd297ada83f00a2d80343424f9e4096c029437a9250ad
-  data.tar.gz: 51c2591400946af23395f0a3f49dfc87d4ce6f536e9cbc045ae7c86915007938c72b90f899dd347d749918218b86edc8dbaa63e8f9430d7075872a431d91b777
+  metadata.gz: b3dd656f73cdf525bda28a2cb5f136f91ae2935f48cfd94f8dc06f042b7f682c2faf48a48625b7845ae058b92189447433c152ab11eeebb8baae925d5371326d
+  data.tar.gz: 84ae987e64b8c872351d259d88a1e8b63b7926e06f9bda7a0d71dda4826e4e17c83fdc5538bcde63cc0d16f77ffd75c57b504947a692898d552a77e1814a7c44

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

@@ -567,7 +567,7 @@ module Sequel
         im = input_identifier_meth(opts[:dataset])
         table = SQL::Identifier.new(im.call(table_name))
         table = SQL::QualifiedIdentifier.new(im.call(opts[:schema]), table) if opts[:schema]
-        metadata_dataset.with_sql("DESCRIBE ?", table).map do |row|
+        metadata_dataset.with_sql("SHOW FULL COLUMNS FROM ?", table).map do |row|
           extra = row.delete(:Extra)
           if row[:primary_key] = row.delete(:Key) == 'PRI'
             row[:auto_increment] = !!(extra.to_s =~ /auto_increment/i)
@@ -577,10 +577,14 @@ module Sequel
             row[:generated] = !!(extra.to_s =~ /VIRTUAL|STORED|PERSISTENT/i)
           end
           row[:allow_null] = row.delete(:Null) == 'YES'
+          row[:comment] = row.delete(:Comment)
+          row[:comment] = nil if row[:comment] == ""
           row[:default] = row.delete(:Default)
           row[:db_type] = row.delete(:Type)
           row[:type] = schema_column_type(row[:db_type])
           row[:extra] = extra
+          row.delete(:Collation)
+          row.delete(:Privileges)
           [m.call(row.delete(:Field)), row]
         end
       end

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

@@ -1075,6 +1075,7 @@ module Sequel
               pg_attribute[:attname].as(:name),
               SQL::Cast.new(pg_attribute[:atttypid], :integer).as(:oid),
               SQL::Cast.new(basetype[:oid], :integer).as(:base_oid),
+              SQL::Function.new(:col_description, pg_class[:oid], pg_attribute[:attnum]).as(:comment),
               SQL::Function.new(:format_type, basetype[:oid], pg_type[:typtypmod]).as(:db_base_type),
               SQL::Function.new(:format_type, pg_type[:oid], pg_attribute[:atttypmod]).as(:db_type),
               SQL::Function.new(:pg_get_expr, pg_attrdef[:adbin], pg_class[:oid]).as(:default),
@@ -2387,6 +2388,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/adapters/trilogy.rb

@@ -62,8 +62,7 @@ module Sequel
       private
 
       def database_specific_error_class(exception, opts)
-        case exception.message
-        when /1205 - Lock wait timeout exceeded; try restarting transaction\z/
+        if exception.error_code == 1205
           DatabaseLockTimeout
         else
           super

data/lib/sequel/database/misc.rb

@@ -246,9 +246,13 @@ module Sequel
     # extension does not have specific support for Database objects, an Error will be raised.
     # Returns self.
     def extension(*exts)
-      Sequel.extension(*exts)
       exts.each do |ext|
-        if pr = Sequel.synchronize{EXTENSIONS[ext]}
+        unless pr = Sequel.synchronize{EXTENSIONS[ext]}
+          Sequel.extension(ext)
+          pr = Sequel.synchronize{EXTENSIONS[ext]}
+        end
+
+        if pr
           if Sequel.synchronize{@loaded_extensions.include?(ext) ? false : (@loaded_extensions << ext)}
             pr.call(self)
           end

data/lib/sequel/dataset/query.rb

@@ -204,7 +204,7 @@ module Sequel
       # If no related extension file exists or the extension does not have
       # specific support for Dataset objects, an error will be raised.
       def extension(*exts)
-        Sequel.extension(*exts)
+        exts.each{|ext| Sequel.extension(ext) unless Sequel.synchronize{EXTENSIONS[ext]}}
         mods = exts.map{|ext| Sequel.synchronize{EXTENSION_MODULES[ext]}}
         if mods.all?
           with_extend(*mods)
@@ -1359,9 +1359,13 @@ module Sequel
     unless TRUE_FREEZE
       # Load the extensions into the receiver, without checking if the receiver is frozen.
       def _extension!(exts)
-        Sequel.extension(*exts)
         exts.each do |ext|
-          if pr = Sequel.synchronize{EXTENSIONS[ext]}
+          unless pr = Sequel.synchronize{EXTENSIONS[ext]}
+            Sequel.extension(ext)
+            pr = Sequel.synchronize{EXTENSIONS[ext]}
+          end
+
+          if pr
             pr.call(self)
           else
             raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")

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/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_auto_parameterize.rb

@@ -394,7 +394,7 @@ module Sequel
         # there can be more than one parameter per column, so this doesn't prevent going
         # over the limit, though it does make it less likely.
         def default_import_slice
-          40
+          @opts[:no_auto_parameterize] ? super : 40
         end
 
         # Handle parameterization of multi_insert_sql

data/lib/sequel/extensions/pg_schema_caching.rb

@@ -0,0 +1,90 @@
+# frozen-string-literal: true
+#
+# The pg_schema_caching extension builds on top of the schema_caching
+# extension, and allows it to handle custom PostgreSQL types. On
+# PostgreSQL, column schema hashes include an :oid entry for the OID
+# for the column's type.  For custom types, this OID is dependent on
+# the PostgreSQL database, so in most cases, test and development
+# versions of the same database, created with the same migrations,
+# will have different OIDs.
+#
+# To fix this case, the pg_schema_caching extension removes custom
+# OIDs from the schema cache when dumping the schema, replacing them
+# with a placeholder. When loading the cached schema, the Database
+# object makes a single query to get the OIDs for all custom types
+# used by the cached schema, and it updates all related column
+# schema hashes to set the correct :oid entry for the current
+# database.
+#
+# Related module: Sequel::Postgres::SchemaCaching
+
+require_relative "schema_caching"
+
+module Sequel
+  module Postgres
+    module SchemaCaching
+      include Sequel::SchemaCaching
+
+      private
+
+      # Load custom oids from database when loading schema cache file.
+      def load_schema_cache_file(file)
+        set_custom_oids_for_cached_schema(super)
+      end
+
+      # Find all column schema hashes that use custom types.
+      # Load the oids for custom types in a single query, and update
+      # each related column schema hash with the correct oid.
+      def set_custom_oids_for_cached_schema(schemas)
+        custom_oid_rows = {}
+
+        schemas.each_value do |cols|
+          cols.each do |_, h|
+            if h[:oid] == :custom
+              (custom_oid_rows[h[:db_type]] ||= []) << h
+            end
+          end
+        end
+
+        unless custom_oid_rows.empty?
+          from(:pg_type).where(:typname=>custom_oid_rows.keys).select_hash(:typname, :oid).each do |name, oid|
+            custom_oid_rows.delete(name).each do |row|
+              row[:oid] = oid
+            end
+          end
+        end
+
+        unless custom_oid_rows.empty?
+          warn "Could not load OIDs for the following custom types: #{custom_oid_rows.keys.sort.join(", ")}", uplevel: 3
+
+          schemas.keys.each do |k|
+            if schemas[k].any?{|_,h| h[:oid] == :custom}
+              # Remove schema entry for table, so it will be queried at runtime to get the correct oids
+              schemas.delete(k)
+            end
+          end
+        end
+
+        schemas
+      end
+
+      # Replace :oid entries for custom types with :custom.
+      def dumpable_schema_cache
+        sch = super
+
+        sch.each_value do |cols|
+          cols.each do |_, h|
+            if (oid = h[:oid]) && oid >= 10000
+              h[:oid] = :custom
+            end
+          end
+        end
+
+        sch
+      end
+    end
+  end
+
+  Database.register_extension(:pg_schema_caching, Postgres::SchemaCaching)
+end
+

data/lib/sequel/extensions/schema_caching.rb

@@ -51,14 +51,7 @@ module Sequel
   module SchemaCaching
     # Dump the cached schema to the filename given in Marshal format.
     def dump_schema_cache(file)
-      sch = {}
-      @schemas.sort.each do |k,v|
-        sch[k] = v.map do |c, h|
-          h = Hash[h]
-          h.delete(:callable_default)
-          [c, h]
-        end
-      end
+      sch = dumpable_schema_cache
       File.open(file, 'wb'){|f| f.write(Marshal.dump(sch))}
       nil
     end
@@ -72,7 +65,7 @@ module Sequel
     # Replace the schema cache with the data from the given file, which
     # should be in Marshal format.
     def load_schema_cache(file)
-      @schemas = Marshal.load(File.read(file))
+      @schemas = load_schema_cache_file(file)
       @schemas.each_value{|v| schema_post_process(v)}
       nil
     end
@@ -82,6 +75,28 @@ module Sequel
     def load_schema_cache?(file)
       load_schema_cache(file) if File.exist?(file)
     end
+
+    private
+
+    # Return the deserialized schema cache file.
+    def load_schema_cache_file(file)
+      Marshal.load(File.read(file))
+    end
+
+    # A dumpable version of the schema cache.
+    def dumpable_schema_cache
+      sch = {}
+
+      @schemas.sort.each do |k,v|
+        sch[k] = v.map do |c, h|
+          h = Hash[h]
+          h.delete(:callable_default)
+          [c, h]
+        end
+      end
+
+      sch
+    end
   end
 
   Database.register_extension(:schema_caching, SchemaCaching)

data/lib/sequel/extensions/sqlite_json_ops.rb

@@ -35,7 +35,7 @@
 #
 #   j[1]                     # (json_column ->> 1)
 #   j.get(1)                 # (json_column ->> 1)
-#   j.get_text(1)            # (json_column -> 1)
+#   j.get_json(1)            # (json_column -> 1)
 #   j.extract('$.a')         # json_extract(json_column, '$.a')
 #   jb.extract('$.a')        # jsonb_extract(jsonb_column, '$.a')
 #

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/model/base.rb

@@ -87,7 +87,7 @@ module Sequel
       attr_reader :simple_pk
   
       # Should be the literal table name if this Model's dataset is a simple table (no select, order, join, etc.),
-      # or nil otherwise.  This and simple_pk are used for an optimization in Model.[].
+      # or nil otherwise.  This and simple_pk are used for an optimization in Model[].
       attr_reader :simple_table
   
       # Whether mass assigning via .create/.new/#set/#update should raise an error
@@ -398,7 +398,7 @@ module Sequel
       end
   
       # Finds a single record according to the supplied filter.
-      # You are encouraged to use Model.[] or Model.first instead of this method.
+      # You are encouraged to use Model[] or Model.first instead of this method.
       #
       #   Artist.find(name: 'Bob')
       #   # SELECT * FROM artists WHERE (name = 'Bob') LIMIT 1
@@ -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 ||= Module.new}
+        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
@@ -1311,7 +1324,7 @@ module Sequel
       # Returns a string representation of the model instance including
       # the class name and values.
       def inspect
-        "#<#{model.name} @values=#{inspect_values}>"
+        "#<#{inspect_prefix} @values=#{inspect_values}>"
       end
   
       # Returns the keys in +values+.  May not include all column names.
@@ -1994,7 +2007,12 @@ module Sequel
         set(h) unless h.empty?
       end
 
-      # Default inspection output for the values hash, overwrite to change what #inspect displays.
+      # Default inspect output for the inspect, by default, just showing the class.
+      def inspect_prefix
+        model.name
+      end
+
+      # Default inspect output for the values hash, overwrite to change what #inspect displays.
       def inspect_values
         @values.inspect
       end

data/lib/sequel/plugins/inspect_pk.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The inspect_pk plugin includes the pk right next to the
+    # model name in inspect, allowing for easily copying and
+    # pasting to retrieve a copy of the object:
+    #
+    #   Album.with_pk(1).inspect
+    #   #         default: #<Album @values={...}>
+    #   # with inspect_pk: #<Album[1] @values={...}>
+    #
+    # Usage:
+    #
+    #   # Make all model instances include pk in inspect output
+    #   Sequel::Model.plugin :inspect_pk
+    #
+    #   # Make Album instances include pk in inspect output
+    #   Album.plugin :inspect_pk
+    module InspectPk
+      module InstanceMethods
+        private
+
+        # The primary key value to include in the inspect output, if any.
+        # For composite primary keys, this only includes a value if all
+        # fields are present.
+        def inspect_pk
+          if primary_key && (pk = self.pk) && (!(Array === pk) || pk.all?)
+            pk
+          end
+        end
+
+        # Include the instance's primary key in the output.
+        def inspect_prefix
+          if v = inspect_pk
+            "#{super}[#{v.inspect}]"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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]}

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_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 ||= Module.new}
+          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/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 = 86
+  MINOR = 88
 
   # 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.86.0
+  version: 5.88.0
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-01 00:00:00.000000000 Z
+date: 2025-01-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -268,6 +267,7 @@ files:
 - lib/sequel/extensions/pg_range_ops.rb
 - lib/sequel/extensions/pg_row.rb
 - lib/sequel/extensions/pg_row_ops.rb
+- lib/sequel/extensions/pg_schema_caching.rb
 - lib/sequel/extensions/pg_static_cache_updater.rb
 - lib/sequel/extensions/pg_timestamptz.rb
 - lib/sequel/extensions/pretty_table.rb
@@ -353,6 +353,7 @@ files:
 - lib/sequel/plugins/input_transformer.rb
 - lib/sequel/plugins/insert_conflict.rb
 - lib/sequel/plugins/insert_returning_select.rb
+- lib/sequel/plugins/inspect_pk.rb
 - lib/sequel/plugins/instance_filters.rb
 - lib/sequel/plugins/instance_hooks.rb
 - lib/sequel/plugins/instance_specific_default.rb
@@ -390,6 +391,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
@@ -422,7 +424,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"
@@ -444,8 +445,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []