sequel 5.90.0 → 5.91.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba9973675e3b9e358ff96c334052ab6ba73e1db4c87c455163b60e367d0eb568
-  data.tar.gz: 86c4197ba9ced0d6bd3a789e5c20e4d0656bf5baca103f0b6db33e45b7981258
+  metadata.gz: d13e0998a9eb78392a4f9f7793b2ceceebf87fa5a4dd6f9fcfd5bbd05a686d83
+  data.tar.gz: d4c7da82fb811928c58a096b2d5fc500cdb7cee1bbff14795817b5bd3f4d3360
 SHA512:
-  metadata.gz: 0247f84faceeb8a8c97d85bdefc3d0b781986e630981c163ca58bf7965f852a472d9e9501c5913ee1f4e7b02c005817c76ae8e71fcb0479fae252b27662e05f7
-  data.tar.gz: f90672de6e1ae901dca735988fa1466647bdc8f0cfeba75c1f27892e14e4eaf316b0141906039c9a33a70150b1860cda1f7a1972858ece6e3752614a91a60f2c
+  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/pg_auto_parameterize_in_array.rb

@@ -21,11 +21,17 @@
 # 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 two or
 # more elements, where all elements are of the same class (other than
@@ -42,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,
@@ -61,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
 
@@ -73,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 >= (db.typecast_value(:integer, db.opts[:pg_auto_parameterize_min_array_size]) || 2)
+        return unless Array === r && r.size >= pg_auto_parameterize_min_array_size
         classes = r.map(&:class)
         classes.uniq!
         classes.delete(NilClass)
@@ -86,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
@@ -105,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/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]
@@ -1931,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)
@@ -3608,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/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/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 = 90
+  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.90.0
+  version: 5.91.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-03-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,7 @@ files:
 - lib/sequel/plugins/paged_operations.rb
 - lib/sequel/plugins/pg_array_associations.rb
 - lib/sequel/plugins/pg_auto_constraint_validations.rb
+- lib/sequel/plugins/pg_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