sequel 5.89.0 → 5.91.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8248e272e580f0e89e508e2aa97ebea83ac083b3f1bd347fc9d34700fd98ae42
-  data.tar.gz: a74658ae42f7e087a541056d5f0cac2db4cc67b11ca56367b2bea309e502df49
+  metadata.gz: d13e0998a9eb78392a4f9f7793b2ceceebf87fa5a4dd6f9fcfd5bbd05a686d83
+  data.tar.gz: d4c7da82fb811928c58a096b2d5fc500cdb7cee1bbff14795817b5bd3f4d3360
 SHA512:
-  metadata.gz: c2875a0f53a46efa87b3380b3fe2c1bbae46542076e3e5615ddcd53b55ac6dfefa53fc828ec4f1277df85a7852eb0e2934377d074e58a6410837138ed2e2a7db
-  data.tar.gz: 8c1a3591085be13aef51f3bc63f0407249858c57e91c3f314b92d929d362c4aafd0b801ee52ca0f96acb18f6fa133d33c4532b5a0fc13fc61e599ba3e05f4e6c
+  metadata.gz: c2bbfc37fbd2b97796c96352a0f1d7d41053f91f4b61e3888a5aea712b9a59c7600e8ed58a15919cef7d8b0cc1c35e4bc3d142206ac245ed6f4f13575188f3b9
+  data.tar.gz: 8f4c0b7b95ec967c471455df69e8b5b5ff9c2104790c7c18abaa9601f2e7c4514952d4410aac1e3f720304f30af2d7299ea0f1233a7e083bcb901c8a03f697bb

data/lib/sequel/adapters/ado.rb

@@ -179,7 +179,7 @@ module Sequel
       
       def adapter_initialize
         case @opts[:conn_string]
-        when /Microsoft\.(Jet|ACE)\.OLEDB/io
+        when /Microsoft\.(Jet|ACE)\.OLEDB/i
           require_relative 'ado/access'
           extend Sequel::ADO::Access::DatabaseMethods
           self.dataset_class = ADO::Access::Dataset

data/lib/sequel/adapters/jdbc.rb

@@ -636,11 +636,11 @@ module Sequel
       def schema_column_set_db_type(schema)
         case schema[:type]
         when :string
-          if schema[:db_type] =~ /\A(character( varying)?|n?(var)?char2?)\z/io && schema[:column_size] > 0
+          if schema[:db_type] =~ /\A(character( varying)?|n?(var)?char2?)\z/i && schema[:column_size] > 0
             schema[:db_type] += "(#{schema[:column_size]})"
           end
         when :decimal
-          if schema[:db_type] =~ /\A(decimal|numeric)\z/io && schema[:column_size] > 0 && schema[:scale] >= 0
+          if schema[:db_type] =~ /\A(decimal|numeric)\z/i && schema[:column_size] > 0 && schema[:scale] >= 0
             schema[:db_type] += "(#{schema[:column_size]}, #{schema[:scale]})"
           end
         end

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

@@ -480,11 +480,11 @@ module Sequel
       
       def schema_column_type(db_type)
         case db_type
-        when /\A(?:bit)\z/io
+        when /\A(?:bit)\z/i
           :boolean
-        when /\A(?:(?:small)?money)\z/io
+        when /\A(?:(?:small)?money)\z/i
           :decimal
-        when /\A(timestamp|rowversion)\z/io
+        when /\A(timestamp|rowversion)\z/i
           :blob
         else
           super

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

@@ -550,11 +550,11 @@ module Sequel
 
       def schema_column_type(db_type)
         case db_type
-        when /\Aset/io
+        when /\Aset/i
           :set
-        when /\Amediumint/io
+        when /\Amediumint/i
           :integer
-        when /\Amediumtext/io
+        when /\Amediumtext/i
           :string
         else
           super

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

@@ -1663,9 +1663,9 @@ module Sequel
       # Handle interval and citext types.
       def schema_column_type(db_type)
         case db_type
-        when /\Ainterval\z/io
+        when /\Ainterval\z/i
           :interval
-        when /\Acitext\z/io
+        when /\Acitext\z/i
           :string
         else
           super

data/lib/sequel/database/query.rb

@@ -170,7 +170,7 @@ module Sequel
         c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type]) unless c.has_key?(:ruby_default)
         if c[:primary_key] && !auto_increment_set
           # If adapter didn't set it, assume that integer primary keys are auto incrementing
-          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/io)
+          c[:auto_increment] = primary_keys == 1 && !!(c[:db_type] =~ /int/i)
         end
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
@@ -390,25 +390,25 @@ module Sequel
     # such as :integer or :string.
     def schema_column_type(db_type)
       case db_type
-      when /\A(character( varying)?|n?(var)?char|n?text|string|clob)/io
+      when /\A(character( varying)?|n?(var)?char|n?text|string|clob)/i
         :string
-      when /\A(int(eger)?|(big|small|tiny)int)/io
+      when /\A(int(eger)?|(big|small|tiny)int)/i
         :integer
-      when /\Adate\z/io
+      when /\Adate\z/i
         :date
-      when /\A((small)?datetime|timestamp(\(\d\))?( with(out)? time zone)?)\z/io
+      when /\A((small)?datetime(\(\d\))?|timestamp(\(\d\))?( with(out)? time zone)?)\z/i
         :datetime
-      when /\Atime( with(out)? time zone)?\z/io
+      when /\Atime( with(out)? time zone)?\z/i
         :time
-      when /\A(bool(ean)?)\z/io
+      when /\A(bool(ean)?)\z/i
         :boolean
-      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
+      when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/i
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/i
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
-      when /bytea|blob|image|(var)?binary/io
+      when /bytea|blob|image|(var)?binary/i
         :blob
-      when /\Aenum/io
+      when /\Aenum/i
         :enum
       end
     end

data/lib/sequel/extensions/connection_validator.rb

@@ -119,7 +119,7 @@ module Sequel
               end
 
               disconnect_connection(conn)
-              redo
+              redo if valid == false
             end
           end
         end

data/lib/sequel/extensions/pg_auto_parameterize_in_array.rb

@@ -21,15 +21,26 @@
 # DateTime :: timestamp (or timestamptz if pg_timestamptz extension is used)
 # Sequel::SQLTime :: time
 # Sequel::SQL::Blob :: bytea
+#
+# Arrays of string values are not automatically converted by default, because the Ruby
+# String class can represent a number of different database types.  To convert
+# arrays of Ruby strings to an untyped array (a query parameter with no explicit
+# type cast), set the +:treat_string_list_as_untyped_array+ Database option
+# before loading the extension.
 # 
-# String values are also supported using the +text+ type, but only if the 
-# +:treat_string_list_as_text_array+ Database option is used. This is because
-# treating strings as text can break programs, since the type for
-# literal strings in PostgreSQL is +unknown+, not +text+.
+# If you will only be using arrays of Ruby strings that represent the +text+ type,
+# you can use the +:treat_string_list_as_text_array+ Database option is used. This
+# 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
 
@@ -37,6 +48,47 @@ module Sequel
   module Postgres
     # Enable automatically parameterizing queries.
     module AutoParameterizeInArray
+      module TreatStringListAsUntypedArray
+        # Sentinal value to use as an auto param type to use auto parameterization
+        # of a string array without an explicit type cast.
+        NO_EXPLICIT_CAST = Object.new.freeze
+
+        # Wrapper for untyped PGArray values that will be parameterized directly
+        # into the query.  This should only be used in cases where you know the
+        # value should be added as a query parameter.
+        class ParameterizedUntypedPGArray < SQL::Wrapper
+          def to_s_append(ds, sql)
+            sql.add_arg(@value)
+          end
+        end
+
+        private
+
+        # Recognize NO_EXPLICIT_CAST sentinal value and use wrapped
+        # PGArray that will be parameterized into the query.
+        def _convert_array_to_pg_array_with_type(r, type)
+          if NO_EXPLICIT_CAST.equal?(type)
+            ParameterizedUntypedPGArray.new(Sequel.pg_array(r))
+          else
+            super
+          end
+        end
+
+        # Use a query parameter with no type cast for string arrays.
+        def _bound_variable_type_for_string_array(r)
+          NO_EXPLICIT_CAST
+        end
+      end
+
+      module TreatStringListAsTextArray
+        private
+
+        # Assume all string arrays used on RHS of IN/NOT IN are for type text[]
+        def _bound_variable_type_for_string_array(r)
+          "text"
+        end
+      end
+
       # Transform column IN (...) expressions into column = ANY($)
       # and column NOT IN (...) expressions into column != ALL($)
       # using an array bound variable for the ANY/ALL argument,
@@ -56,7 +108,7 @@ module Sequel
               op = :!=
               func = :ALL
             end
-            args = [l, Sequel.function(func, Sequel.pg_array(r, type))]
+            args = [l, Sequel.function(func, _convert_array_to_pg_array_with_type(r, type))]
           end
         end
 
@@ -68,7 +120,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 >= pg_auto_parameterize_min_array_size
         classes = r.map(&:class)
         classes.uniq!
         classes.delete(NilClass)
@@ -81,7 +133,7 @@ module Sequel
           # arrays natively (though the SQL used is different)
           "int8"
         elsif klass == String
-          "text" if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+          _bound_variable_type_for_string_array(r)
         elsif klass == BigDecimal
           "numeric"
         elsif klass == Date
@@ -100,11 +152,42 @@ module Sequel
           "bytea"
         end
       end
+
+      # Do not auto parameterize string arrays by default.
+      def _bound_variable_type_for_string_array(r)
+        nil
+      end
+
+      # The minimium size of array to auto parameterize.
+      def pg_auto_parameterize_min_array_size
+        2
+      end
+
+      # Convert RHS of IN/NOT IN operator to PGArray with given type.
+      def _convert_array_to_pg_array_with_type(r, type)
+        Sequel.pg_array(r, type)
+      end
     end
   end
 
   Database.register_extension(:pg_auto_parameterize_in_array) do |db|
     db.extension(:pg_array, :pg_auto_parameterize)
     db.extend_datasets(Postgres::AutoParameterizeInArray)
+
+    if db.typecast_value(:boolean, db.opts[:treat_string_list_as_text_array])
+      db.extend_datasets(Postgres::AutoParameterizeInArray::TreatStringListAsTextArray)
+    elsif db.typecast_value(:boolean, db.opts[:treat_string_list_as_untyped_array])
+      db.extend_datasets(Postgres::AutoParameterizeInArray::TreatStringListAsUntypedArray)
+    end
+
+    if min_array_size = db.opts[:pg_auto_parameterize_min_array_size]
+      min_array_size = db.typecast_value(:integer, min_array_size)
+      mod = Module.new do
+        define_method(:pg_auto_parameterize_min_array_size){min_array_size}
+        private :pg_auto_parameterize_min_array_size
+      end
+      Sequel.set_temp_name(mod){"Sequel::Postgres::AutoParameterizeInArray::_MinArraySize#{min_array_size}"}
+      db.extend_datasets(mod)
+    end
   end
 end

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

@@ -257,7 +257,7 @@ END_MIG
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)
-          if [Integer, :Bignum, Float, BigDecimal].include?(type) && schema[:db_type] =~ / unsigned\z/io
+          if [Integer, :Bignum, Float, BigDecimal].include?(type) && schema[:db_type] =~ / unsigned\z/i
             gen.check(Sequel::SQL::Identifier.new(name) >= 0)
           end
         end

data/lib/sequel/model/associations.rb

@@ -414,6 +414,12 @@ module Sequel
           false
         end
 
+        # Hash value for the association reflection.  This is precomputed to avoid
+        # concurrency issues at runtime.
+        def hash
+          self[:_hash]
+        end
+
         # Initialize the associations cache for the current association for the given objects.
         def initialize_association_cache(objects)
           name = self[:name]
@@ -693,6 +699,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 +768,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 +1724,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 +1789,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 +1914,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)
@@ -1914,6 +1937,8 @@ module Sequel
           # Remove :class entry if it exists and is nil, to work with cached_fetch
           opts.delete(:class) unless opts[:class]
 
+          opts[:_hash] = [self, name].hash
+
           def_association(opts)
       
           orig_opts.delete(:clone)
@@ -3591,7 +3616,7 @@ module Sequel
 
         # Prepare a hash loaders and eager options which will be used to implement the eager loading.
         def prepare_eager_load(a, reflections, eager_assoc)
-          eager_load_data = {}
+          eager_load_data = {}.compare_by_identity
 
           # Key is foreign/primary key name symbol.
           # Value is hash with keys being foreign/primary key values (generally integers)

data/lib/sequel/model/base.rb

@@ -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 ||= Sequel.set_temp_name(Module.new){"#{name}::@dataset_methods_module"}}
+        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 = Sequel.set_temp_name(Module.new){"#{name}::@overridable_methods_module"}) 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/forbid_lazy_load.rb

@@ -39,6 +39,9 @@ module Sequel
     #
     #   Album.first.artist # no error
     #
+    # This behavior of enabling +forbid_lazy_load+ automatically from dataset
+    # methods can be disabled using the plugin's +:allow_by_default+ option.
+    #
     # You can allow lazy loading associations for an instance that it
     # was previously forbidden for:
     # 
@@ -98,7 +101,17 @@ module Sequel
     #
     #   # Make the Album class support forbidding lazy load
     #   Album.plugin :forbid_lazy_load
+    #
+    #   # Let lazy loading be forbidden by object, but not automatically for any
+    #   # object loaded via dataset.
+    #   Album.plugin :forbid_lazy_load, allow_by_default: true
     module ForbidLazyLoad
+      def self.apply(model, opts=OPTS)
+        unless opts[:allow_by_default]
+          model.send(:dataset_extend, ForbidByDefault, :create_class_methods=>false)
+        end
+      end
+
       # Error raised when attempting to lazy load an association when
       # lazy loading has been forbidden.
       class Error < StandardError
@@ -179,7 +192,7 @@ module Sequel
         end
       end
 
-      module DatasetMethods
+      module ForbidByDefault
         # Mark model instances retrieved in this call as forbidding lazy loading.
         def each
           if row_proc

data/lib/sequel/plugins/nested_attributes.rb

@@ -188,11 +188,10 @@ module Sequel
         
         # Create a new associated object with the given attributes, validate
         # it when the parent is validated, and save it when the object is saved.
-        # Returns the object created.
+        # Returns the new object.
         def nested_attributes_create(meta, attributes)
+          obj = nested_attributes_new(meta, attributes)
           reflection = meta[:reflection]
-          obj = reflection.associated_class.new
-          nested_attributes_set_attributes(meta, obj, attributes)
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
             public_send(reflection[:name]) << obj
@@ -254,7 +253,13 @@ module Sequel
           end
           obj
         end
-        
+
+        # Returns a new object of the associated class with the given attributes set.
+        def nested_attributes_new(meta, attributes)
+          obj = meta[:reflection].associated_class.new
+          nested_attributes_set_attributes(meta, obj, attributes)
+        end
+
         # Set the fields in the obj based on the association, only allowing
         # specific :fields if configured.
         def nested_attributes_set_attributes(meta, obj, attributes)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -135,7 +135,12 @@ module Sequel
           raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
           pg_auto_constraint_validations_cache = {}
           @pg_auto_constraint_validations_cache.sort.each do |k, v|
-            pg_auto_constraint_validations_cache[k] = v
+            h = {}
+            v.each do |k, entry|
+              entry = Hash[entry.sort] if entry.is_a?(Hash)
+              h[k] = entry
+            end
+            pg_auto_constraint_validations_cache[k] = h
           end
           File.open(file, 'wb'){|f| f.write(Marshal.dump(pg_auto_constraint_validations_cache))}
           nil

data/lib/sequel/plugins/pg_auto_validate_enums.rb

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The pg_auto_validate_enums plugin implements automatic validations for
+    # enum columns, ensuring that enum columns have a valid value.  With this
+    # plugin, trying to save with an invalid enum value results in
+    # Sequel::ValidationFailed before saving, instead of Sequel::DatabaseError
+    # (wrapping PG::InvalidTextRepresentation or similar exception) during saving.
+    # 
+    #   class Person < Sequel::Model
+    #     # assume state enum column with allowed values active and inactive
+    #     plugin :pg_auto_validate_enums
+    #   end
+    #   p = Person.new(state: "active").valid? # => true
+    #   p = Person.new(state: "inactive").valid? # => true
+    #   p = Person.new(state: "other").valid? # => false
+    #
+    # While you can load this into individual model classes, typical use would
+    # be to load it into Sequel::Model or the appropriate model base class,
+    # and have all models that inherit from that class automatically pick it up.
+    #
+    # This plugin depends on the validation_helpers plugin.
+    module PgAutoValidateEnums
+      # Load the validation_helpers plugin.
+      def self.apply(model, opts=OPTS)
+        model.plugin(:validation_helpers)
+      end
+
+      # Load the pg_enum extension into the database, and reload the schema
+      # if it is already loaded. The opts given are used for the validates_includes
+      # validations (with allow_nil: true and from: :values enabled by default,
+      # to avoid issues with nullable enum columns and cases where the column
+      # method has been overridden.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          db.extension(:pg_enum) unless @db.instance_variable_get(:@enum_labels)
+          if @db_schema
+            get_db_schema(true)
+            _get_pg_pg_auto_validate_enums_metadata
+          end
+          @pg_auto_validate_enums_opts = {allow_nil: true, from: :values}.merge!(opts).freeze
+        end
+      end
+
+      module ClassMethods
+        # Hash with enum column symbol values and arrays of valid string values.
+        attr_reader :pg_auto_validate_enums_metadata
+
+        # Options to pass to the validates_includes calls used by the plugin.
+        attr_reader :pg_auto_validate_enums_opts
+
+        Plugins.after_set_dataset(self, :_get_pg_pg_auto_validate_enums_metadata)
+
+        Plugins.inherited_instance_variables(self,
+          :@pg_auto_validate_enums_metadata=>nil,
+          :@pg_auto_validate_enums_opts=>nil)
+
+        private
+
+        # Parse the column schema to find columns with :enum_values entries,
+        # which will be used to setup validations.
+        def _get_pg_pg_auto_validate_enums_metadata
+          metadata = {}
+          @db_schema.each do |key, sch|
+            if enum_values = sch[:enum_values]
+              metadata[key] = enum_values
+            end
+          end
+          @pg_auto_validate_enums_metadata = metadata.freeze
+        end
+      end
+
+      module InstanceMethods
+        # Validate that all of the model's enum columns have valid values.
+        def validate
+          super
+
+          klass = self.class
+          opts = klass.pg_auto_validate_enums_opts
+          klass.pg_auto_validate_enums_metadata.each do |column, values|
+            validates_includes(values, column, opts)
+          end
+        end
+      end
+    end
+  end
+end

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

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 ||= Sequel.set_temp_name(Module.new){"#{name}::@subset_static_cache_module"}}
+          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

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 = 89
+  MINOR = 91
 
   # 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.89.0
+  version: 5.91.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-02-01 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -371,6 +371,8 @@ 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_auto_validate_enums.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