sequel 5.65.0 → 5.67.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24bfe7c123337539140b0385dd9a828fe0fec4d6ad4e39e5fd8f150258ae7a03
-  data.tar.gz: d820be46e60ba7b08b1129f0a6b67a24a550a27d5b682a84730172bc256f4118
+  metadata.gz: ff5af191af88ca381359503cfd9601ec8f18a9d782b68a3de4a8c9dac080eddc
+  data.tar.gz: 786d20f7eac9325748c259130951643856e34051e64b02aa17493f6d0283eb52
 SHA512:
-  metadata.gz: bd5c7dacdf48f8ada7c34c88210ac804faa1b47741f946ca16cd6f645c1f86055eb85ac6b601e9cef2ab4aa8a5cba3dc444e3005d6ed61d324c1158f2e03a70e
-  data.tar.gz: d17eb580a3f50f4b0c33561aed320c2ea3089044b905f4dc845ea8682afe1cdbf2798c6cd202f1233b1d168d06c9686a94728d41e0f47264245a33da5a99b251
+  metadata.gz: db251488ea0739af5ecf6db332a1cff729cffbf31dfabfc7235f3c27f807366bc9feddf147797e4dd5980348fda6a640cc5ceef7e6255cddcd317acb7172be90
+  data.tar.gz: 45b0e24847ccb365f1d7d06d35c85f05718802375877ab3d0315deb952f72171e26b5676861c25cf1e840f831d216f99eaddcbb717fc752d75077f19ae13980c

data/CHANGELOG

@@ -1,3 +1,27 @@
+=== 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)
+
+* Make Dataset#count work correctly for datasets using Dataset#values (jeremyevans) (#1992)
+
+* Make Dataset#count with no argument/block handle dataset with custom SQL using ORDER BY on MSSQL (jeremyevans)
+
+* Make Dataset#empty? correctly handle datasets with custom SQL or using Dataset#values where the first value is NULL (andy-k, jeremyevans) (#1990)
+
 === 5.65.0 (2023-02-01)
 
 * Allow pg_auto_parameterize extension to use placeholder loaders (jeremyevans)

data/doc/release_notes/5.66.0.txt

@@ -0,0 +1,24 @@
+= Improvements
+
+* Dataset#empty? now correctly handles datasets using custom SQL or
+  Dataset#values where the first value in the first row is NULL.
+
+* Dataset#count without an argument or block now works correctly on
+  Microsoft SQL Server when using custom SQL that uses ORDER BY.
+
+* Dataset#count now works correctly for datasets using Dataset#values.
+
+* Sequel now recognizes an additional SQLite constraint violation
+  error that occurs with recent versions of amalgalite.
+
+* Dataset#values will now raise an exception when called with an empty
+  array. Previously, an exception would not be raised until the query
+  was sent to the database.
+
+= Backwards Compatibility
+
+* The changes to make Dataset#empty? and #count work with custom SQL
+  on Microsoft SQL Server now result in running the custom SQL, which
+  could result in worse performance than in previous versions. You can
+  wrap such datasets with Dataset#from_self manually to restore the
+  previous behavior.

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/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.
@@ -591,6 +596,18 @@ module Sequel
         end
       end
       
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Load entire query in this case to get
+      # the number of rows. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def count(*a, &block)
+        if (@opts[:sql] && a.empty? && !block)
+          naked.to_a.length
+        else
+          super
+        end
+      end
+
       # Uses CROSS APPLY to join the given table into the current dataset.
       def cross_apply(table)
         join_table(:cross_apply, table)
@@ -601,6 +618,19 @@ module Sequel
         clone(:disable_insert_output=>true)
       end
 
+      # For a dataset with custom SQL, since it may include ORDER BY, you
+      # cannot wrap it in a subquery.  Run query, and if it returns any
+      # records, return true. In general, you should avoid calling this method
+      # on datasets with custom SQL.
+      def empty?
+        if @opts[:sql]
+          naked.each{return false}
+          true
+        else
+          super
+        end
+      end
+
       # MSSQL treats [] as a metacharacter in LIKE expresions.
       def escape_like(string)
         string.gsub(/[\\%_\[\]]/){|m| "\\#{m}"}

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

@@ -385,7 +385,12 @@ module Sequel
       # Use a custom expression with EXISTS to determine whether a dataset
       # is empty.
       def empty?
-        db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
+        if @opts[:sql]
+          naked.each{return false}
+          true
+        else
+          db[:dual].where(@opts[:offset] ? exists : unordered.exists).get(1) == nil
+        end
       end
 
       # Oracle requires SQL standard datetimes

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

@@ -805,6 +805,7 @@ module Sequel
       #   DB.values([[1, 2], [3, 4]]).order(:column2).limit(1, 1)
       #   # VALUES ((1, 2), (3, 4)) ORDER BY column2 LIMIT 1 OFFSET 1
       def values(v)
+        raise Error, "Cannot provide an empty array for values" if v.empty?
         @default_dataset.clone(:values=>v)
       end
 
@@ -1706,6 +1707,12 @@ module Sequel
         clone(:disable_insert_returning=>true)
       end
 
+      # Always return false when using VALUES
+      def empty?
+        return false if @opts[:values]
+        super
+      end
+
       # Return the results of an EXPLAIN query as a string
       def explain(opts=OPTS)
         with_sql((opts[:analyze] ? 'EXPLAIN ANALYZE ' : 'EXPLAIN ') + select_sql).map(:'QUERY PLAN').join("\r\n")
@@ -2125,6 +2132,11 @@ module Sequel
         "TRUNCATE TABLE#{' ONLY' if to[:only]} #{table}#{' RESTART IDENTITY' if to[:restart]}#{' CASCADE' if to[:cascade]}"
       end
 
+      # Use from_self for aggregate dataset using VALUES.
+      def aggreate_dataset_use_from_self?
+        super || @opts[:values]
+      end
+      
       # Allow truncation of multiple source tables.
       def check_truncation_allowed!
         raise(InvalidOperation, "Grouped datasets cannot be truncated") if opts[:group]

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

@@ -169,6 +169,7 @@ module Sequel
       #   DB.values([[1, 2], [3, 4]])
       #   # VALUES ((1, 2), (3, 4))
       def values(v)
+        raise Error, "Cannot provide an empty array for values" if v.empty?
         @default_dataset.clone(:values=>v)
       end
 
@@ -356,6 +357,7 @@ module Sequel
       DATABASE_ERROR_REGEXPS = {
         /(is|are) not unique\z|PRIMARY KEY must be unique\z|UNIQUE constraint failed: .+\z/ => UniqueConstraintViolation,
         /foreign key constraint failed\z/i => ForeignKeyConstraintViolation,
+        /\ASQLITE ERROR 3091/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 275 \(CONSTRAINT_CHECK\) : )?CHECK constraint failed/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed\z/ => ConstraintViolation,
         /\Acannot store [A-Z]+ value in [A-Z]+ column / => ConstraintViolation,
@@ -655,6 +657,12 @@ module Sequel
         @opts[:where] ? super : where(1=>1).delete(&block)
       end
       
+      # Always return false when using VALUES
+      def empty?
+        return false if @opts[:values]
+        super
+      end
+
       # Return an array of strings specifying a query explanation for a SELECT of the
       # current dataset. Currently, the options are ignored, but it accepts options
       # to be compatible with other adapters.
@@ -868,6 +876,11 @@ module Sequel
         end
       end
 
+      # Use from_self for aggregate dataset using VALUES.
+      def aggreate_dataset_use_from_self?
+        super || @opts[:values]
+      end
+      
       # SQLite uses string literals instead of identifiers in AS clauses.
       def as_sql_append(sql, aliaz, column_aliases=nil)
         raise Error, "sqlite does not support derived column lists" if column_aliases

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

@@ -174,7 +174,7 @@ module Sequel
     #   # => false
     def empty?
       cached_dataset(:_empty_ds) do
-        single_value_ds.unordered.select(EMPTY_SELECT)
+        (@opts[:sql] ? from_self : self).single_value_ds.unordered.select(EMPTY_SELECT)
       end.single_value!.nil?
     end
 

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

@@ -977,7 +977,12 @@ module Sequel
     # order if not. Also removes the row_proc, which isn't needed
     # for aggregate calculations.
     def aggregate_dataset
-      (options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered).naked
+      (aggreate_dataset_use_from_self? ? from_self : unordered).naked
+    end
+
+    # Whether to use from_self for an aggregate dataset.
+    def aggreate_dataset_use_from_self?
+      options_overlap(COUNT_FROM_SELF_OPTS)
     end
 
     # Append aliasing expression to SQL string.

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/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/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/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 = 65
+  MINOR = 67
 
   # 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.65.0
+  version: 5.67.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-01 00:00:00.000000000 Z
+date: 2023-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -197,6 +197,8 @@ extra_rdoc_files:
 - doc/release_notes/5.63.0.txt
 - 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.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -290,6 +292,8 @@ files:
 - doc/release_notes/5.63.0.txt
 - 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.7.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
@@ -374,6 +378,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
@@ -459,6 +464,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
@@ -613,7 +619,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: The Database Toolkit for Ruby