sequel 5.66.0 → 5.68.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7284ac53d44e98a2ddaf7c0e8068fe0716a9071bef14c484bbe77cc553d775f0
-  data.tar.gz: '0828c8d85355205f8b6ee8a58ba5f9b85ebec07381a687f08fa909e883ac8eed'
+  metadata.gz: e682467c455e044847fffb313b6d8a669e0dc89ca8ea330468841de642b84227
+  data.tar.gz: cd0687fd059a6b6d38cb31279d5cdacccd4a0a309f1155171f12551d43eacb0b
 SHA512:
-  metadata.gz: d5e42c07446ea4cd3b42eb566a20cf81b4fb7e641d7b521ead6bcfc32a8ff0a0bf7b76d7a2a8ba654a0bdd80a67db6def93ba1efba61dd5eeebf68a14cdb722a
-  data.tar.gz: ad7397637ab9bfb0903eff1c46c8ed5901bc2eff3a4ba5a2411ba61fb32f9e6d00871063cc55f6d21798f5790f0a5158c19f0343839a6d6750b53a3301395c90
+  metadata.gz: 3c16f027251aa67e04cab0973a57da21682e083c7362f37bdbf84937266ca6878e200fb7c44a0583b8ac6fab62d1fd4b55744929760fc63a9d1f850452db5df6
+  data.tar.gz: 60eee01297c47ee9c18ae76b6974b6eb3e492e58c7f408ee9c32476f1ae0ae5848ffc47cb80889f7070b02088e7e66509b64e460a1ef61c90ffb5a59da6a3c09

data/CHANGELOG

@@ -1,3 +1,29 @@
+=== 5.68.0 (2023-05-01)
+
+* Add validation_helpers_generic_type_messages plugin for more useful type validation failure messages (jeremyevans) (#2028)
+
+* Make constraint_validations plugin not validate missing columns that have a default value (jeremyevans) (#2023)
+
+* Skip normal type name parsing for enum/array/composite/range/multirange types on PostgreSQL (jeremyevans) (#2019)
+
+* Fix corner case where pg_extended_date_support did not work correctly when using the jdbc/postgresql adapter (jeremyevans)
+
+* Include :min_value and :max_value schema entries for date/timestamp/timestamptz columns on PostgreSQL 9.6+ (jeremyevans)
+
+=== 5.67.0 (2023-04-01)
+
+* Fix dumping of string column sizes in the schema dumper on MSSQL (jeremyevans) (#2013)
+
+* Improve dumping of tables in non-default schemas in the schema_dumper extension (jeremyevans) (#2006)
+
+* Make Database#{tables,views} support :qualify option on Microsoft SQL Server (jeremyevans)
+
+* Avoid use of singleton classes for datasets instances on Ruby 2.4+ (jeremyevans) (#2007)
+
+* Deprecate registering datasets extensions using an object other than a module (jeremyevans)
+
+* Add set_literalizer extension, for treating set usage in datasets similar to array usage (jeremyevans) (#1997)
+
 === 5.66.0 (2023-03-01)
 
 * Recognize SQLite error related to strict tables as a constraint violation when using the amalgalite adapter (jeremyevans)

data/doc/advanced_associations.rdoc

@@ -670,8 +670,10 @@ polymorphic associations in Sequel about as easy as it is in ActiveRecord.  Howe
 here's how they can be done using Sequel's custom associations (the sequel_polymorphic
 external plugin is just a generic version of this code):
 
+  Sequel.extension :inflector # for attachable_type.constantize
+
   class Asset < Sequel::Model
-    many_to_one :attachable, reciprocal: :assets,
+    many_to_one :attachable, reciprocal: :assets, reciprocal_type: :one_to_many,
       setter: (lambda do |attachable|
         self[:attachable_id] = (attachable.pk if attachable)
         self[:attachable_type] = (attachable.class.name if attachable)

data/doc/release_notes/5.67.0.txt

@@ -0,0 +1,32 @@
+= New Features
+
+* A set_literalizer extension has been added, for treating Set
+  instances in datasets similar to Array instances:
+
+    DB.extension :set_literalizer
+    DB[:table].where(column: Set.new([1, 2, 3]))
+    # SELECT FROM table WHERE (column IN (1, 2, 3))
+
+= Improvements
+
+* Sequel now avoids the use of singleton classes for datasets on Ruby
+  2.4+, instead creating a regular subclass whenever a dataset would
+  be extended via #extension or #with_extend.  This significantly
+  improves performance, up to 20-40% for common dataset usage,
+  because it avoids creating new singleton classes for every dataset
+  clone, and it allows for cached method lookup.
+
+* Database#tables and #views now support a :qualify option on Microsoft
+  SQL Server to returned qualified identifiers.
+
+* The schema_dumper extension can now dump tables in non-default schemas
+  when using Microsoft SQL Server.
+
+* The schema_dumper extension now correctly dumps string column sizes
+  when using Microsoft SQL Server.
+
+= Backwards Compatibility
+
+* Calling Sequel::Dataset.register_extension where the second argument
+  is not a module now issues a deprecation warning.  Support for this
+  will be removed in Sequel 6.

data/doc/release_notes/5.68.0.txt

@@ -0,0 +1,61 @@
+= New Features
+
+* On PostgreSQL 9.6+, date, timestamp, and timestamptz columns now
+  have min_value and max_value column schema entries, allowing the
+  auto_validations plugin to automatically enforce minimum and
+  maximum values for these column types, raising a validation error
+  before saving, instead of database error when the query is sent
+  to the database.
+
+* A validation_helpers_generic_type_messages plugin has been added,
+  which improves the default type validation error messages in
+  validation_helpers.  This change was not made directly to
+  validation_helpers for backwards compatibility reasons, but will
+  probably become the default behavior in Sequel 6.  Some examples
+  of the improvements:
+
+    # :blob type
+    # validation_helpers default: "value is not a valid sequel::sql::blob"
+    # with this plugin: "value is not a blob"
+
+    # :boolean type
+    # validation_helpers default: "value is not a valid trueclass or falseclass"
+    # with this plugin: "value is not true or false"
+
+    # :datetime type
+    # validation_helpers default: "value is not a valid time or datetime"
+    # with this plugin: "value is not a valid timestamp"
+
+    # custom/database-specific types
+    # validation_helpers default: "value is not a valid sequel::class_name"
+    # with this plugin: "value is not the expected type"
+
+= Improvements
+
+* The constraint_validations plugin no longer raises validation
+  errors for missing columns that have a default value. If a column
+  is missing but has a default value, we can assume the default
+  value is valid.  Additionally, the constraint validations are now
+  based on the underlying column value and not any deserialized
+  value, so that the validation matches the constraint.
+
+* On PostgreSQL, normal type name parsing is skipped for enum,
+  array, composite, range, and multirange types, ensuring that
+  such types will not be treated incorrectly based on their
+  type name.
+
+* The pg_extended_date_support extension now works correctly with
+  the jdbc/postgresql adapter if there is already an entry in the
+  oid_convertor_map for the timestamp and timestamptz types.
+
+= Backwards Compatibility
+
+* Database#schema_column_type is no longer called for all columns
+  on PostgreSQL when parsing schema. Enum, array, composite, range,
+  and multirange types each have their own separate type parsing
+  method.  So if you were overriding Database#schema_column_type to
+  implement custom column schema parsing, you may need to adjust
+  your code.
+
+* The Sequel::Postgres::ExtendedDateSupport::DATE_YEAR_1 constant
+  has been removed.

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

@@ -404,10 +404,15 @@ module Sequel
       # Backbone of the tables and views support.
       def information_schema_tables(type, opts)
         m = output_identifier_meth
-        metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
+        schema = opts[:schema]||'dbo'
+        tables = metadata_dataset.from(Sequel[:information_schema][:tables].as(:t)).
           select(:table_name).
-          where(:table_type=>type, :table_schema=>(opts[:schema]||'dbo').to_s).
+          where(:table_type=>type, :table_schema=>schema.to_s).
           map{|x| m.call(x[:table_name])}
+
+        tables.map!{|t| Sequel.qualify(m.call(schema).to_s, m.call(t).to_s)} if opts[:qualify]
+
+        tables
       end
 
       # Always quote identifiers in the metadata_dataset, so schema parsing works.

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

@@ -1007,11 +1007,15 @@ module Sequel
               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),
               SQL::BooleanExpression.new(:NOT, pg_attribute[:attnotnull]).as(:allow_null),
-              SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(pg_attribute[:attnum] => SQL::Function.new(:ANY, pg_index[:indkey])), false).as(:primary_key)]}.
+              SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(pg_attribute[:attnum] => SQL::Function.new(:ANY, pg_index[:indkey])), false).as(:primary_key),
+              Sequel[:pg_type][:typtype],
+              (~Sequel[Sequel[:elementtype][:oid]=>nil]).as(:is_array),
+            ]}.
             from(:pg_class).
             join(:pg_attribute, :attrelid=>:oid).
             join(:pg_type, :oid=>:atttypid).
             left_outer_join(Sequel[:pg_type].as(:basetype), :oid=>:typbasetype).
+            left_outer_join(Sequel[:pg_type].as(:elementtype), :typarray=>Sequel[:pg_type][:oid]).
             left_outer_join(:pg_attrdef, :adrelid=>Sequel[:pg_class][:oid], :adnum=>Sequel[:pg_attribute][:attnum]).
             left_outer_join(:pg_index, :indrelid=>Sequel[:pg_class][:oid], :indisprimary=>true).
             where{{pg_attribute[:attisdropped]=>false}}.
@@ -1538,11 +1542,12 @@ module Sequel
       end
 
       # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
-      # a rename table operation, so speciying a new schema in new_name will not have an effect.
+      # a rename table operation, so specifying a new schema in new_name will not have an effect.
       def rename_table_sql(name, new_name)
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
       end
 
+      # Handle interval and citext types.
       def schema_column_type(db_type)
         case db_type
         when /\Ainterval\z/io
@@ -1554,6 +1559,43 @@ module Sequel
         end
       end
 
+      # The schema :type entry to use for array types.
+      def schema_array_type(db_type)
+        :array
+      end
+
+      # The schema :type entry to use for row/composite types.
+      def schema_composite_type(db_type)
+        :composite
+      end
+
+      # The schema :type entry to use for enum types.
+      def schema_enum_type(db_type)
+        :enum
+      end
+
+      # The schema :type entry to use for range types.
+      def schema_range_type(db_type)
+        :range
+      end
+
+      # The schema :type entry to use for multirange types.
+      def schema_multirange_type(db_type)
+        :multirange
+      end
+
+      MIN_DATE = Date.new(-4713, 11, 24)
+      MAX_DATE = Date.new(5874897, 12, 31)
+      MIN_TIMESTAMP = Time.utc(-4713, 11, 24).freeze
+      MAX_TIMESTAMP = (Time.utc(294277) - Rational(1, 1000000)).freeze
+      TYPTYPE_METHOD_MAP = {
+        'c' => :schema_composite_type,
+        'e' => :schema_enum_type,
+        'r' => :schema_range_type,
+        'm' => :schema_multirange_type,
+      }
+      TYPTYPE_METHOD_MAP.default = :schema_column_type
+      TYPTYPE_METHOD_MAP.freeze
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])
@@ -1569,11 +1611,33 @@ module Sequel
             row.delete(:base_oid)
             row.delete(:db_base_type)
           end
-          row[:type] = schema_column_type(row[:db_type])
+
+          db_type = row[:db_type]
+          row[:type] = if row.delete(:is_array)
+            schema_array_type(db_type)
+          else
+            send(TYPTYPE_METHOD_MAP[row.delete(:typtype)], db_type)
+          end
           identity = row.delete(:attidentity)
           if row[:primary_key]
             row[:auto_increment] = !!(row[:default] =~ /\A(?:nextval)/i) || identity == 'a' || identity == 'd'
           end
+
+          # :nocov:
+          if server_version >= 90600
+          # :nocov:
+            case row[:oid]
+            when 1082
+              row[:min_value] = MIN_DATE
+              row[:max_value] = MAX_DATE
+            when 1184, 1114
+              if Sequel.datetime_class == Time
+                row[:min_value] = MIN_TIMESTAMP
+                row[:max_value] = MAX_TIMESTAMP
+              end
+            end
+          end
+
           [m.call(row.delete(:name)), row]
         end
       end

data/lib/sequel/database/dataset.rb

@@ -30,19 +30,29 @@ module Sequel
       @dataset_class.new(self)
     end
 
-    # Fetches records for an arbitrary SQL statement. If a block is given,
-    # it is used to iterate over the records:
+    # Returns a dataset instance for the given SQL string:
     #
-    #   DB.fetch('SELECT * FROM items'){|r| p r}
+    #   ds = DB.fetch('SELECT * FROM items')
+    #
+    # You can then call methods on the dataset to retrieve results:
     #
-    # The +fetch+ method returns a dataset instance:
+    #   ds.all
+    #   # SELECT * FROM items
+    #   # => [{:column=>value, ...}, ...]
     #
-    #   DB.fetch('SELECT * FROM items').all
+    # If a block is given, it is passed to #each on the resulting dataset to
+    # iterate over the records returned by the query:
+    #
+    #   DB.fetch('SELECT * FROM items'){|r| p r}
+    #   # {:column=>value, ...}
+    #   # ...
     #
     # +fetch+ can also perform parameterized queries for protection against SQL
     # injection:
     #
-    #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).all
+    #   ds = DB.fetch('SELECT * FROM items WHERE name = ?', "my name")
+    #   ds.all
+    #   # SELECT * FROM items WHERE name = 'my name'
     #
     # See caveats listed in Dataset#with_sql regarding datasets using custom
     # SQL and the methods that can be called on them.

data/lib/sequel/database/schema_generator.rb

@@ -307,7 +307,7 @@ module Sequel
       # Examples:
       #   primary_key(:id)
       #   primary_key(:id, type: :Bignum, keep_order: true)
-      #   primary_key([:street_number, :house_number], name: :some constraint_name)
+      #   primary_key([:street_number, :house_number], name: :some_constraint_name)
       def primary_key(name, *args)
         return composite_primary_key(name, *args) if name.is_a?(Array)
         column = @db.serial_primary_key_options.merge({:name => name})

data/lib/sequel/database/schema_methods.rb

@@ -900,7 +900,7 @@ module Sequel
     #
     # Any other object given is just converted to a string, with "_" converted to " " and upcased.
     def on_delete_clause(action)
-      action.to_s.gsub("_", " ").upcase
+      action.to_s.tr("_", " ").upcase
     end
 
     # Alias of #on_delete_clause, since the two usually behave the same.

data/lib/sequel/dataset/deprecated_singleton_class_methods.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+module Sequel
+  class Dataset
+    # This module implements methods to support deprecated use of extensions registered
+    # not using a module.  In such cases, for backwards compatibility, Sequel has to use
+    # a singleton class for the dataset.
+    module DeprecatedSingletonClassMethods
+      # Load the extension into a clone of the receiver.
+      def extension(*a)
+        c = _clone(:freeze=>false)
+        c.send(:_extension!, a)
+        c.freeze
+      end
+
+      # Extend the cloned of the receiver with the given modules, instead of the default
+      # approach of creating a subclass of the receiver's class and including the modules
+      # into that.
+      def with_extend(*mods, &block)
+        c = _clone(:freeze=>false)
+        c.extend(*mods) unless mods.empty?
+        c.extend(DatasetModule.new(&block)) if block
+        c.freeze
+      end
+
+      private
+
+      # Load the extensions into the receiver.
+      def _extension!(exts)
+        Sequel.extension(*exts)
+        exts.each do |ext|
+          if pr = Sequel.synchronize{EXTENSIONS[ext]}
+            pr.call(self)
+          else
+            raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel/dataset/query.rb

@@ -12,6 +12,10 @@ module Sequel
     # in the extension).
     EXTENSIONS = {}
 
+    # Hash of extension name symbols to modules to load to implement the extension.
+    EXTENSION_MODULES = {}
+    private_constant :EXTENSION_MODULES
+
     EMPTY_ARRAY = [].freeze
 
     # The dataset options that require the removal of cached columns if changed.
@@ -45,12 +49,8 @@ module Sequel
     METHS
 
     # Register an extension callback for Dataset objects.  ext should be the
-    # extension name symbol, and mod should either be a Module that the
-    # dataset is extended with, or a callable object called with the database
-    # object.  If mod is not provided, a block can be provided and is treated
-    # as the mod object.
-    #
-    # If mod is a module, this also registers a Database extension that will
+    # extension name symbol, and mod should be a Module that will be
+    # included in the dataset's class. This also registers a Database extension that will
     # extend all of the database's datasets.
     def self.register_extension(ext, mod=nil, &block)
       if mod
@@ -58,10 +58,16 @@ module Sequel
         if mod.is_a?(Module)
           block = proc{|ds| ds.extend(mod)}
           Sequel::Database.register_extension(ext){|db| db.extend_datasets(mod)}
+          Sequel.synchronize{EXTENSION_MODULES[ext] = mod}
         else
           block = mod
         end
       end
+
+      unless mod.is_a?(Module)
+        Sequel::Deprecation.deprecate("Providing a block or non-module to Sequel::Dataset.register_extension is deprecated and support for it will be removed in Sequel 6.")
+      end
+
       Sequel.synchronize{EXTENSIONS[ext] = block}
     end
 
@@ -195,11 +201,15 @@ module Sequel
     if TRUE_FREEZE
       # Return a clone of the dataset loaded with the given dataset extensions.
       # If no related extension file exists or the extension does not have
-      # specific support for Dataset objects, an Error will be raised.
-      def extension(*a)
-        c = _clone(:freeze=>false)
-        c.send(:_extension!, a)
-        c.freeze
+      # specific support for Dataset objects, an error will be raised.
+      def extension(*exts)
+        Sequel.extension(*exts)
+        mods = exts.map{|ext| Sequel.synchronize{EXTENSION_MODULES[ext]}}
+        if mods.all?
+          with_extend(*mods)
+        else
+          with_extend(DeprecatedSingletonClassMethods).extension(*exts)
+        end
       end
     else
       # :nocov:
@@ -1199,16 +1209,27 @@ module Sequel
     end
     
     if TRUE_FREEZE
-      # Return a clone of the dataset extended with the given modules.
+      # Create a subclass of the receiver's class, and include the given modules
+      # into it. If a block is provided, a DatasetModule is created using the block and
+      # is included into the subclass.  Create an instance of the subclass using the
+      # same db and opts, so that the returned dataset operates similarly to a clone
+      # extended with the given modules.  This approach is used to avoid singleton
+      # classes, which significantly improves performance.
+      #
       # Note that like Object#extend, when multiple modules are provided
-      # as arguments the cloned dataset is extended with the modules in reverse
-      # order.  If a block is provided, a DatasetModule is created using the block and
-      # the clone is extended with that module after any modules given as arguments.
+      # as arguments the subclass includes the modules in reverse order.
       def with_extend(*mods, &block)
-        c = _clone(:freeze=>false)
-        c.extend(*mods) unless mods.empty?
-        c.extend(DatasetModule.new(&block)) if block
-        c.freeze
+        c = Class.new(self.class)
+        c.include(*mods) unless mods.empty?
+        c.include(DatasetModule.new(&block)) if block
+        o = c.freeze.allocate
+        o.instance_variable_set(:@db, @db)
+        o.instance_variable_set(:@opts, @opts)
+        o.instance_variable_set(:@cache, {})
+        if cols = cache_get(:_columns)
+          o.send(:columns=, cols)
+        end
+        o.freeze
       end
     else
       # :nocov:
@@ -1315,18 +1336,22 @@ module Sequel
 
     private
 
-    # 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]}
-          pr.call(self)
-        else
-          raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+    # :nocov:
+    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]}
+            pr.call(self)
+          else
+            raise(Error, "Extension #{ext} does not have specific support handling individual datasets (try: Sequel.extension #{ext.inspect})")
+          end
         end
+        self
       end
-      self
     end
+    # :nocov:
 
     # If invert is true, invert the condition.
     def _invert_filter(cond, invert)

data/lib/sequel/dataset.rb

@@ -53,4 +53,8 @@ module Sequel
   require_relative "dataset/sql"
   require_relative "dataset/placeholder_literalizer"
   require_relative "dataset/dataset_module"
+
+  # :nocov:
+  require_relative "dataset/deprecated_singleton_class_methods" if Dataset::TRUE_FREEZE
+  # :nocov:
 end

data/lib/sequel/extensions/connection_validator.rb

@@ -28,7 +28,7 @@
 # connections on every checkout without setting up coarse
 # connection checkouts will hurt performance, in some cases
 # significantly.  Note that setting up coarse connection
-# checkouts reduces the concurrency level acheivable.  For
+# checkouts reduces the concurrency level achievable.  For
 # example, in a web application, using Database#synchronize
 # in a rack middleware will limit the number of concurrent
 # web requests to the number to connections in the database

data/lib/sequel/extensions/pg_array.rb

@@ -257,7 +257,7 @@ module Sequel
         end
 
         # Make the column type detection handle registered array types.
-        def schema_column_type(db_type)
+        def schema_array_type(db_type)
           if (db_type =~ /\A([^(]+)(?:\([^(]+\))?\[\]\z/io) && (type = pg_array_schema_type($1))
             type
           else

data/lib/sequel/extensions/pg_enum.rb

@@ -166,8 +166,7 @@ module Sequel
       def schema_post_process(_)
         super.each do |_, s|
           oid = s[:oid]
-          if values = Sequel.synchronize{@enum_labels[oid]}
-            s[:type] = :enum
+          if s[:type] == :enum && (values = Sequel.synchronize{@enum_labels[oid]})
             s[:enum_values] = values
           end
         end

data/lib/sequel/extensions/pg_extended_date_support.rb

@@ -22,7 +22,6 @@
 module Sequel
   module Postgres
     module ExtendedDateSupport
-      DATE_YEAR_1 = Date.new(1)
       DATETIME_YEAR_1 = DateTime.new(1)
       TIME_YEAR_1 = Time.at(-62135596800).utc
       INFINITE_TIMESTAMP_STRINGS = ['infinity'.freeze, '-infinity'.freeze].freeze
@@ -38,6 +37,15 @@ module Sequel
         procs = db.conversion_procs
         procs[1082] = ::Sequel.method(:string_to_date)
         procs[1184] = procs[1114] = db.method(:to_application_timestamp)
+        if ocps = db.instance_variable_get(:@oid_convertor_map)
+          # Clear the oid convertor map entries for timestamps if they
+          # exist, so it will regenerate new ones that use this extension.
+          # This is only taken when using the jdbc adapter.
+          Sequel.synchronize do
+            ocps.delete(1184)
+            ocps.delete(1114)
+          end
+        end
       end
 
       # Handle BC dates and times in bound variables. This is necessary for Date values
@@ -181,7 +189,7 @@ module Sequel
 
         # Handle BC Date objects.
         def literal_date(date)
-          if date < DATE_YEAR_1
+          if date.year < 1
             date <<= ((date.year) * 24 - 12)
             date.strftime("'%Y-%m-%d BC'")
           else

data/lib/sequel/extensions/pg_multirange.rb

@@ -221,7 +221,7 @@ module Sequel
         private
 
         # Recognize the registered database multirange types.
-        def schema_column_type(db_type)
+        def schema_multirange_type(db_type)
           @pg_multirange_schema_types[db_type] || super
         end
 

data/lib/sequel/extensions/pg_range.rb

@@ -234,7 +234,7 @@ module Sequel
         private
 
         # Recognize the registered database range types.
-        def schema_column_type(db_type)
+        def schema_range_type(db_type)
           @pg_range_schema_types[db_type] || super
         end
 

data/lib/sequel/extensions/pg_row.rb

@@ -538,12 +538,8 @@ module Sequel
         private
 
         # Make the column type detection handle registered row types.
-        def schema_column_type(db_type)
-          if type = @row_schema_types[db_type]
-            type
-          else
-            super
-          end
+        def schema_composite_type(db_type)
+          @row_schema_types[db_type] || super
         end
       end
     end

data/lib/sequel/extensions/schema_dumper.rb

@@ -88,11 +88,11 @@ module Sequel
     # Note that the migration this produces does not have a down
     # block, so you cannot reverse it.
     def dump_foreign_key_migration(options=OPTS)
-      ts = tables(options)
+      ts = _dump_tables(options)
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.map{|t| dump_table_foreign_keys(t)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
@@ -106,11 +106,11 @@ END_MIG
     #                 set to :namespace, prepend the table name to the index name if the
     #                 database does not use a global index namespace.
     def dump_indexes_migration(options=OPTS)
-      ts = tables(options)
+      ts = _dump_tables(options)
       <<END_MIG
 Sequel.migration do
   change do
-#{ts.sort.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
+#{ts.map{|t| dump_table_indexes(t, :add_index, options)}.reject{|x| x == ''}.join("\n\n").gsub(/^/, '    ')}
   end
 end
 END_MIG
@@ -138,7 +138,7 @@ END_MIG
         options[:foreign_keys] = false
       end
 
-      ts = sort_dumped_tables(tables(options), options)
+      ts = sort_dumped_tables(_dump_tables(options), options)
       skipped_fks = if sfk = options[:skipped_foreign_keys]
         # Handle skipped foreign keys by adding them at the end via
         # alter_table/add_foreign_key.  Note that skipped foreign keys
@@ -166,6 +166,21 @@ END_MIG
 
     private
         
+    # Handle schema option to dump tables in a different schema. Such
+    # tables must be schema qualified for this to work correctly.
+    def _dump_tables(opts)
+      if opts[:schema]
+        _literal_table_sort(tables(opts.merge(:qualify=>true)))
+      else
+        tables(opts).sort
+      end
+    end
+
+    # Sort the given table by the literalized value.
+    def _literal_table_sort(tables)
+      tables.sort_by{|s| literal(s)}
+    end
+
     # If a database default exists and can't be converted, and we are dumping with :same_db,
     # return a string with the inspect method modified a literal string is created if the code is evaled.  
     def column_schema_to_ruby_default_fallback(default, options)
@@ -204,12 +219,20 @@ END_MIG
           if database_type == :mysql && h[:type] =~ /\Atimestamp/
             h[:null] = true
           end
+          if database_type == :mssql && schema[:max_length]
+            h[:size] = schema[:max_length]
+          end
           h
         else
           column_schema_to_ruby_type(schema)
         end
         type = col_opts.delete(:type)
-        col_opts.delete(:size) if col_opts[:size].nil?
+        if col_opts.key?(:size) && col_opts[:size].nil?
+          col_opts.delete(:size)
+          if max_length = schema[:max_length]
+            col_opts[:size] = max_length
+          end
+        end
         if schema[:generated]
           if options[:same_db] && database_type == :postgres
             col_opts[:generated_always_as] = column_schema_to_ruby_default_fallback(schema[:default], options)
@@ -352,7 +375,7 @@ END_MIG
         options[:skipped_foreign_keys] = skipped_foreign_keys
         tables
       else
-        tables.sort
+        tables
       end
     end
 
@@ -377,14 +400,14 @@ END_MIG
           # outstanding foreign keys and skipping those foreign keys.
           # The skipped foreign keys will be added at the end of the
           # migration.
-          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, table]}.first
+          skip_table, skip_fks = table_fks.sort_by{|table, fks| [fks.length, literal(table)]}.first
           skip_fks_hash = skipped_foreign_keys[skip_table] = {}
           skip_fks.each{|fk| skip_fks_hash[fk[:columns]] = fk}
           this_loop << skip_table
         end
 
         # Add sorted tables from this loop to the final list
-        sorted_tables.concat(this_loop.sort)
+        sorted_tables.concat(_literal_table_sort(this_loop))
 
         # Remove tables that were handled this loop
         this_loop.each{|t| table_fks.delete(t)}

data/lib/sequel/extensions/set_literalizer.rb

@@ -0,0 +1,58 @@
+# frozen-string-literal: true
+#
+# The set_literalizer extension allows for using Set instances in many of the
+# same places that you would use Array instances:
+#
+#   DB[:table].where(column: Set.new([1, 2, 3]))
+#   # SELECT FROM table WHERE (column IN (1, 2, 3))
+#
+# To load the extension into all datasets created from a given Database:
+#
+#   DB.extension :set_literalizer
+#
+# Related module: Sequel::Dataset::SetLiteralizer
+
+require 'set'
+
+module Sequel
+  class Dataset
+    module SetLiteralizer
+      # Try to generate the same SQL for Set instances used in datasets
+      # that would be used for equivalent Array instances.
+      def complex_expression_sql_append(sql, op, args)
+        # Array instances are treated specially by
+        # Sequel::SQL::BooleanExpression.from_value_pairs. That cannot
+        # be modified by a dataset extension, so this tries to convert
+        # the complex expression values generated by default to what would
+        # be the complex expression values used for the equivalent array.
+        case op
+        when :'=', :'!='
+          if (set = args[1]).is_a?(Set)
+            op = op == :'=' ? :IN : :'NOT IN'
+            col = args[0]
+            array = set.to_a
+            if Sequel.condition_specifier?(array) && col.is_a?(Array)
+              array = Sequel.value_list(array)
+            end
+            args = [col, array]
+          end
+        end
+
+        super
+      end
+
+      private
+
+      # Literalize Set instances by converting the set to array.
+      def literal_other_append(sql, v)
+        if Set === v
+          literal_append(sql, v.to_a) 
+        else
+          super
+        end
+      end
+    end
+
+    register_extension(:set_literalizer, SetLiteralizer)
+  end
+end

data/lib/sequel/plugins/constraint_validations.rb

@@ -125,14 +125,15 @@ module Sequel
             ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
-            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
+            allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+            @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
             @constraint_validation_reflections = reflections
           end
         end
 
         # Given a specific database constraint validation metadata row hash, transform
         # it in an validation method call array suitable for splatting to send.
-        def constraint_validation_array(r, reflections)
+        def constraint_validation_array(r, reflections, allow_missing_columns=EMPTY_ARRAY)
           opts = {}
           opts[:message] = r[:message] if r[:message]
           opts[:allow_nil] = true if db.typecast_value(:boolean, r[:allow_nil])
@@ -191,11 +192,13 @@ module Sequel
             reflection_opts[:argument] = arg
           end 
 
-          a << column
-          unless opts.empty?
-            a << opts
+          opts[:from] = :values
+          if column.is_a?(Symbol) && allow_missing_columns.include?(column)
+            opts[:allow_missing] = true
           end
 
+          a << column << opts
+
           if column.is_a?(Array) && column.length == 1
             column = column.first
           end

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -28,7 +28,9 @@ module Sequel
     #
     # This plugin only works on the postgres adapter when using the pg 0.16+ driver,
     # PostgreSQL 9.3+ server, and PostgreSQL 9.3+ client library (libpq). In other cases
-    # it will be a no-op.
+    # it will be a no-op. Additionally, the plugin only handles models that select
+    # from tables.  It does not handle models that select from subqueries, such as
+    # subclasses of models using the class_table_inheritance plugin.
     #
     # Example:
     #

data/lib/sequel/plugins/prepared_statements.rb

@@ -3,7 +3,8 @@
 module Sequel
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
-    # instance level inserts and updates.
+    # instance level inserts and updates. This plugin exists for backwards compatibility
+    # and is not recommended for general use.
     #
     # Note that this plugin is unsafe in some circumstances, as it can allow up to
     # 2^N prepared statements to be created for each type of insert and update query, where

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -5,7 +5,8 @@ module Sequel
     # The prepared_statements_safe plugin modifies the model to reduce the number of
     # prepared statements that can be created, by setting as many columns as possible
     # before creating, and by changing +save_changes+ to save all columns instead of
-    # just the changed ones.
+    # just the changed ones. This plugin exists for backwards compatibility
+    # and is not recommended for general use.
     #
     # This plugin depends on the +prepared_statements+ plugin.
     # 

data/lib/sequel/plugins/validation_helpers.rb

@@ -75,6 +75,10 @@ module Sequel
     #       "#{Array(attribute).join(I18n.t('errors.joiner'))} #{error_msg}"
     #     end
     #   end
+    #
+    # It is recommended that users of this plugin that use validates_schema_types also use
+    # the validation_helpers_generic_type_messages plugin for more useful type validation
+    # failure messages.
     module ValidationHelpers
       DEFAULT_OPTIONS = {
         :exact_length=>{:message=>lambda{|exact| "is not #{exact} characters"}},
@@ -211,7 +215,7 @@ module Sequel
           klass = klass.to_s.constantize if klass.is_a?(String) || klass.is_a?(Symbol)
           validatable_attributes_for_type(:type, atts, opts) do |a,v,m|
             if klass.is_a?(Array) ? !klass.any?{|kls| v.is_a?(kls)} : !v.is_a?(klass)
-              validation_error_message(m, klass)
+              validates_type_error_message(m, klass)
             end
           end
         end
@@ -338,6 +342,9 @@ module Sequel
         def validation_error_message(message, *args)
           message.is_a?(Proc) ? message.call(*args) : message
         end
+
+        # The validation error message for type validations, for the given class.
+        alias validates_type_error_message validation_error_message
       end
     end
   end

data/lib/sequel/plugins/validation_helpers_generic_type_messages.rb

@@ -0,0 +1,73 @@
+# frozen-string-literal: true
+
+require_relative 'validation_helpers'
+
+module Sequel
+  module Plugins
+    # The validation_helpers_generic_type_messages plugin overrides the default
+    # type validation failure messages in the validation_helpers plugin to be
+    # more generic and understandable by the average user, instead of always
+    # be based on the names of the allowed classes for the type.  For example:
+    #
+    #   # :blob type
+    #   # validation_helpers default: "value is not a valid sequel::sql::blob"
+    #   # with this plugin: "value is not a blob"
+    #
+    #   # :boolean type
+    #   # validation_helpers default: "value is not a valid trueclass or falseclass"
+    #   # with this plugin: "value is not true or false"
+    #
+    #   # :datetime type
+    #   # validation_helpers default: "value is not a valid time or datetime"
+    #   # with this plugin: "value is not a valid timestamp"
+    #
+    #   # custom/database-specific types
+    #   # validation_helpers default: "value is not a valid sequel::class_name"
+    #   # with this plugin: "value is not the expected type"
+    #
+    # It is expected that this plugin will become the default behavior of
+    # validation_helpers in Sequel 6.
+    #
+    # To enable this the use of generic type messages for all models, load this
+    # plugin into Sequel::Model.
+    #
+    #   Sequel::Model.plugin :validation_helpers_generic_type_messages
+    module ValidationHelpersGenericTypeMessages
+      OVERRIDE_PROC = ValidationHelpers::DEFAULT_OPTIONS[:type][:message]
+      private_constant :OVERRIDE_PROC
+
+      TYPE_ERROR_STRINGS = {
+        String => 'is not a string'.freeze,
+        Integer => 'is not an integer'.freeze,
+        Date => 'is not a valid date'.freeze,
+        [Time, DateTime].freeze => 'is not a valid timestamp'.freeze,
+        Sequel::SQLTime => 'is not a valid time'.freeze,
+        [TrueClass, FalseClass].freeze => 'is not true or false'.freeze,
+        Float => 'is not a number'.freeze,
+        BigDecimal => 'is not a number'.freeze,
+        Sequel::SQL::Blob => 'is not a blob'.freeze,
+      }
+      TYPE_ERROR_STRINGS.default = "is not the expected type".freeze
+      TYPE_ERROR_STRINGS.freeze
+      private_constant :TYPE_ERROR_STRINGS
+
+      def self.apply(mod)
+        mod.plugin :validation_helpers
+      end
+
+      module InstanceMethods 
+        private
+
+        # Use a generic error message for type validations.
+        def validates_type_error_message(m, klass)
+          # SEQUEL6: Make this the default behavior in validation_helpers
+          if OVERRIDE_PROC.equal?(m)
+            TYPE_ERROR_STRINGS[klass]
+          else
+            super
+          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 = 66
+  MINOR = 68
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.66.0
+  version: 5.68.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-01 00:00:00.000000000 Z
+date: 2023-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -198,6 +198,8 @@ extra_rdoc_files:
 - doc/release_notes/5.64.0.txt
 - doc/release_notes/5.65.0.txt
 - doc/release_notes/5.66.0.txt
+- doc/release_notes/5.67.0.txt
+- doc/release_notes/5.68.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -292,6 +294,8 @@ files:
 - doc/release_notes/5.64.0.txt
 - doc/release_notes/5.65.0.txt
 - doc/release_notes/5.66.0.txt
+- doc/release_notes/5.67.0.txt
+- doc/release_notes/5.68.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -376,6 +380,7 @@ files:
 - lib/sequel/dataset.rb
 - lib/sequel/dataset/actions.rb
 - lib/sequel/dataset/dataset_module.rb
+- lib/sequel/dataset/deprecated_singleton_class_methods.rb
 - lib/sequel/dataset/features.rb
 - lib/sequel/dataset/graph.rb
 - lib/sequel/dataset/misc.rb
@@ -461,6 +466,7 @@ files:
 - lib/sequel/extensions/sequel_4_dataset_methods.rb
 - lib/sequel/extensions/server_block.rb
 - lib/sequel/extensions/server_logging.rb
+- lib/sequel/extensions/set_literalizer.rb
 - lib/sequel/extensions/split_array_nil.rb
 - lib/sequel/extensions/sql_comments.rb
 - lib/sequel/extensions/sql_expr.rb
@@ -579,6 +585,7 @@ files:
 - lib/sequel/plugins/validation_class_methods.rb
 - lib/sequel/plugins/validation_contexts.rb
 - lib/sequel/plugins/validation_helpers.rb
+- lib/sequel/plugins/validation_helpers_generic_type_messages.rb
 - lib/sequel/plugins/whitelist_security.rb
 - lib/sequel/plugins/xml_serializer.rb
 - lib/sequel/sql.rb
@@ -615,7 +622,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: The Database Toolkit for Ruby