sequel 5.99.0 → 5.101.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e5d22a32d8c5f27e15e00203d0c2ce2a2fb3f5352d7b7c25c82389f4947882c
-  data.tar.gz: 81909dc070cc8d48def396ae76e953a1f31dc478b45d3a5fa8b69646bc7df094
+  metadata.gz: 9de2d20e1483de5f15a285b695d5eab98601c26f1e711e378de1a03331f197a1
+  data.tar.gz: 4d7df1811d7242dad22f6c9968fb43feecb5a86fd814aa2ba7434bdb44369cb8
 SHA512:
-  metadata.gz: c24ae48ece66511a09b2d8a5ad8b5b82e7486a4446bcb66108140b8afe449cd9c9e7645a29ca0bbe0c994d5c060a52f1ab4c41434dc068175751b1d6bd57b5dc
-  data.tar.gz: e8acd2e5cb4272bd47aed87e3077018dfc5ba9673856b871c8222eec6b2de1be0843840969e046efc459b52902753e9e0f0e35b95dcdcf31914d98b5f487d78a
+  metadata.gz: a9aa7a3bd15f4f35457aace92b68b4734d367273996dc605d80adbe87bca1c945fc484571cad90149e69807980eea2f8b2a6a6fea85a4a0670c10a082a056a03
+  data.tar.gz: ca5c1eb34d71d16660a0b5eb2b9e5b4c784f06d6e4f89b036f00a62f31b57d564f071b8346bdcb9ebd9cced7bcfbe429e2c50bcda1b8b150d723b1e59105c474

data/lib/sequel/database/schema_generator.rb

@@ -657,9 +657,11 @@ module Sequel
         nil
       end
 
-      # Modify the type of one of the table's column.
+      # Modify the type of one of the table's column. The given options are considered when
+      # determining the new type.
       #
       #   set_column_type(:artist_name, 'char(10)') # ALTER COLUMN artist_name TYPE char(10)
+      #   set_column_type(:artist_name, String, size: 10) # ALTER COLUMN artist_name TYPE varchar(10)
       #
       # PostgreSQL specific options:
       #

data/lib/sequel/database/schema_methods.rb

@@ -486,7 +486,9 @@ module Sequel
     end
 
     def alter_table_set_column_type_sql(table, op)
-      "ALTER COLUMN #{quote_identifier(op[:name])} TYPE #{type_literal(op)}"
+      sql = "ALTER COLUMN #{quote_identifier(op[:name])} TYPE #{type_literal(op)}".dup
+      column_definition_collate_sql(sql, op)
+      sql
     end
 
     def alter_table_set_column_default_sql(table, op)

data/lib/sequel/dataset/actions.rb

@@ -372,6 +372,15 @@ module Sequel
     #   DB[:table].import([:x, :y], DB[:table2].select(:a, :b))
     #   # INSERT INTO table (x, y) SELECT a, b FROM table2 
     #
+    # The return value of this method is undefined and should not be used,
+    # except in two cases:
+    #
+    # * When the <tt>return: :primary_key</tt> option is used.
+    # * On PostgreSQL, when the dataset uses RETURNING. In this case, if
+    #   a single value is returned per row, the return value is an array
+    #   of those values. If multiple values are returned per row, the
+    #   return value is an array of hashes.
+    #
     # Options:
     # :commit_every :: Open a new transaction for every given number of
     #                  records. For example, if you provide a value of 50,

data/lib/sequel/dataset/sql.rb

@@ -638,12 +638,11 @@ module Sequel
         if args.empty?
           sql << str
         else
-          re = /:(#{args.keys.map{|k| Regexp.escape(k.to_s)}.join('|')})\b/
-          while true
+          re = /:(#{Regexp.union(args.keys.map(&:to_s))})\b/
+          until str.empty?
             previous, q, str = str.partition(re)
             sql << previous
-            literal_append(sql, args[($1||q[1..-1].to_s).to_sym]) unless q.empty?
-            break if str.empty?
+            literal_append(sql, args[$1.to_sym]) unless q.empty?
           end
         end
       elsif str.is_a?(Array)

data/lib/sequel/extensions/pg_range.rb

@@ -431,6 +431,7 @@ module Sequel
 
         "#<#{self.class.name} #{range}#{"::#{@db_type}" if @db_type}>"
       end
+      alias to_s inspect
 
       # Append a literalize version of the receiver to the sql.
       def sql_literal_append(ds, sql)

data/lib/sequel/plugins/detect_unnecessary_association_options.rb

@@ -0,0 +1,164 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The detect_unnecessary_association_options plugin can detect unnecessary
+    # association options, and either warn or raise if they are detected.
+    # This allows you to find and remove the unnecessary options.
+    # Association options are considered unnecessary if they specify the same
+    # value as Sequel's defaults.
+    #
+    # To detect unnecessary association options, you should load the plugin
+    # into your model base class (e.g. Sequel::Model) before loading your model
+    # classes. Then, after all models have been loaded, you can call the
+    # detect_unnecessary_association_options on each to check for unnecessary
+    # association options. Additionally, if you are calling finalize_associations,
+    # it will automatically check for unnecessary association options.
+    #
+    # A typical usage would be to combine this with the subclasses plugin:
+    #
+    #   Sequel::Model.plugin :detect_unnecessary_association_options
+    #   Sequel::Model.plugin :subclasses
+    #   # load model classes
+    #
+    #   # implicitly check all subclasses when freezing descendants
+    #   Sequel::Model.freeze_descendants
+    #
+    #   # or, if not freezing all descendants
+    #   Sequel::Model.descendants.each(&:detect_unnecessary_association_options)
+    #
+    # By default, the plugin warns for every unnecessary association option.
+    # To raise an error instead, you can pass the <tt>action: :raise</tt> option when loading the
+    # plugin:
+    #
+    #   Sequel::Model.plugin :detect_unnecessary_association_options, action: :raise
+    #
+    # This plugin only detects the most common unnecessary association options, such as:
+    #
+    # * :class (all associations)
+    # * :key and :primary_key (associations without join tables)
+    # * :join_table, :left_key, :right_key, :left_primary_key, :right_primary_key (single join table associations)
+    # * :left_primary_key, :right_primary_key (*_through_many associations)
+    #
+    # Only association types supported by default or supported by a plugin that
+    # ships with Sequel are supported by this plugin. Other association types are
+    # ignored.
+    module DetectUnnecessaryAssociationOptions
+      def self.configure(model, opts={})
+        model.instance_variable_set(:@detect_unnecessary_association_options_action, opts[:action] || :warn)
+      end
+
+      # Raised if the plugin action is to raise and an unnecessary association option
+      # is detected.
+      class UnnecessaryAssociationOption < Sequel::Error
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@detect_unnecessary_association_options_action => nil)
+
+        # Implicitly check for unnecessary association options when finalizing associations.
+        def finalize_associations
+          res = super
+          detect_unnecessary_association_options
+          res
+        end
+
+        # Check for unnecessary association options.
+        def detect_unnecessary_association_options
+          @association_reflections.each_value do |ref|
+            meth = "detect_unnecessary_association_options_#{ref[:type]}"
+            # Expected to call private methods.
+            # Ignore unrecognized association types.
+            # External association types can define the appropriate method to
+            # support their own unnecessary association option checks.
+            if respond_to?(meth, true)
+              # All recognized association types need same class check
+              _detect_unnecessary_association_options_class(ref)
+              send(meth, ref)
+            end
+          end
+
+          nil
+        end
+
+        private
+
+        # Action to take if an unnecessary association option is detected.
+        def unnecessary_association_options_detected(ref, key)
+          if @detect_unnecessary_association_options_action == :raise
+            raise UnnecessaryAssociationOption, "#{ref.inspect} :#{key} option unnecessary"
+          else
+            warn "#{ref.inspect} :#{key} option unnecessary"
+          end
+        end
+
+        # Detect unnecessary :class option.
+        def _detect_unnecessary_association_options_class(ref)
+          return unless ref[:orig_class]
+
+          h = {}
+          name = ref[:name]
+          late_binding_class_option(h, ref.returns_array? ? singularize(name) : name)
+
+          begin
+            default_association_class = constantize(h[:class_name])
+            actual_association_class = ref.associated_class
+          rescue NameError
+            # Do not warn. For the default association class to not be a valid
+            # constant is expected. For the actual association class to not be
+            # a valid constant is not expected and a bug in the association, but
+            # the job of this plugin is not to detect invalid options, only
+            # unnecessary options.
+          else
+            if default_association_class.equal?(actual_association_class)
+              unnecessary_association_options_detected(ref, "class")
+            end
+          end
+        end
+
+        # Detect other unnecessary options. An option is considered unnecessary
+        # if the key was submitted as an association option and the value for
+        # the option is the same as the given value.
+        def _detect_unnecessary_association_options_key_value(ref, key, value)
+          if ref[:orig_opts].has_key?(key) && ref[:orig_opts][key] == value
+            unnecessary_association_options_detected(ref, key)
+          end
+        end
+
+        # Same as _detect_unnecessary_association_options_key_value, but calls
+        # the default_* method on the association reflection to get the default value.
+        def _detect_unnecessary_association_options_key(ref, key)
+          _detect_unnecessary_association_options_key_value(ref, key, ref.send(:"default_#{key}"))
+        end
+
+        def detect_unnecessary_association_options_many_to_one(ref)
+          _detect_unnecessary_association_options_key(ref, :key)
+          _detect_unnecessary_association_options_key_value(ref, :primary_key, ref.associated_class.primary_key)
+        end
+        alias detect_unnecessary_association_options_pg_array_to_many detect_unnecessary_association_options_many_to_one
+
+        def detect_unnecessary_association_options_one_to_many(ref)
+          _detect_unnecessary_association_options_key(ref, :key)
+          _detect_unnecessary_association_options_key_value(ref, :primary_key, primary_key)
+        end
+        alias detect_unnecessary_association_options_one_to_one detect_unnecessary_association_options_one_to_many
+        alias detect_unnecessary_association_options_many_to_pg_array detect_unnecessary_association_options_one_to_many
+
+        def detect_unnecessary_association_options_many_to_many(ref)
+          [:join_table, :left_key, :right_key].each do |key|
+            _detect_unnecessary_association_options_key(ref, key)
+          end
+          _detect_unnecessary_association_options_key_value(ref, :left_primary_key, primary_key)
+          _detect_unnecessary_association_options_key_value(ref, :right_primary_key, ref.associated_class.primary_key)
+        end
+        alias detect_unnecessary_association_options_one_through_one detect_unnecessary_association_options_many_to_many
+
+        def detect_unnecessary_association_options_many_through_many(ref)
+          _detect_unnecessary_association_options_key_value(ref, :left_primary_key, primary_key)
+          _detect_unnecessary_association_options_key_value(ref, :right_primary_key, ref.associated_class.primary_key)
+        end
+        alias detect_unnecessary_association_options_one_through_many detect_unnecessary_association_options_many_through_many
+      end
+    end
+  end
+end

data/lib/sequel/plugins/single_statement_dataset_destroy.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The single_statement_dataset_destroy plugin makes the
+    # model dataset.destroy method delete all rows in a
+    # single DELETE statement. It runs all before_destroy
+    # hooks before the DELETE, and all after_destroy hooks
+    # after the delete.
+    #
+    # This is not compatible with around_destroy hooks,
+    # so if the model is using custom around_destroy hooks,
+    # dataset.destroy falls back to a separate DELETE statement
+    # per row.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use a single DELETE
+    #   # statement for dataset.destroy
+    #   Sequel::Model.plugin :single_statement_dataset_destroy
+    #
+    #   # Make the Album class use a single DELETE
+    #   # statement for dataset.destroy
+    #   Album.plugin :single_statement_dataset_destroy
+    module SingleStatementDatasetDestroy
+      module DatasetMethods
+        # Destroy all rows in a single DELETE statement. Run the before_destroy
+        # hooks for all rows before the DELETE, and all after_destroy hooks
+        # for all rows after the DELETE. If the model uses an around_destroy
+        # hook, fallback to using a separate DELETE statement per row.
+        def destroy
+          return super unless model.instance_method(:around_destroy).owner == Sequel::Model::InstanceMethods
+
+          db.transaction do
+            rows = all
+            rows.each(&:before_destroy)
+            expected_rows = rows.length
+            n = delete
+            unless n == expected_rows
+              raise Error, "dataset changed during destroy, expected rows: #{expected_rows}, actual rows: #{n}"
+            end
+            rows.each(&:after_destroy)
+            n
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/unused_associations.rb

@@ -198,7 +198,8 @@ module Sequel
     #
     # Since this plugin is based on coverage information, if you do
     # not have tests that cover all usage of associations in your
-    # application, you can end up with coverage that shows the
+    # application, or you are mocking the related association methods
+    # and not calling them, you can end up with coverage that shows the
     # association is not used, when it is used in code that is not
     # covered.  The output of plugin can still be useful in such cases,
     # as long as you are manually checking it.  However, you should
@@ -208,6 +209,8 @@ module Sequel
     # option for any association that you know is used. If an
     # association uses the :is_used association option, this plugin
     # will not modify it if the :modify_associations option is used.
+    # It will also not report the association as unused if the :is_used
+    # association option is present.
     #
     # This plugin does not handle anonymous classes. Any unused
     # associations defined in anonymous classes will not be
@@ -362,6 +365,9 @@ module Sequel
               # looks in the class's overridable_methods_module
               next if ref[:methods_module]
 
+              # Do not report associations if they are explicitly marked as used.
+              next if ref[:is_used]
+
               info = {}
               if reflection_data.include?(assoc.to_s)
                 info[:used] = [:reflection]

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 = 99
+  MINOR = 101
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.99.0
+  version: 5.101.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -344,6 +344,7 @@ files:
 - lib/sequel/plugins/defaults_setter.rb
 - lib/sequel/plugins/delay_add_association.rb
 - lib/sequel/plugins/deprecated_associations.rb
+- lib/sequel/plugins/detect_unnecessary_association_options.rb
 - lib/sequel/plugins/dirty.rb
 - lib/sequel/plugins/eager_each.rb
 - lib/sequel/plugins/eager_graph_eager.rb
@@ -386,6 +387,7 @@ files:
 - lib/sequel/plugins/serialization.rb
 - lib/sequel/plugins/serialization_modification_detection.rb
 - lib/sequel/plugins/sharding.rb
+- lib/sequel/plugins/single_statement_dataset_destroy.rb
 - lib/sequel/plugins/single_table_inheritance.rb
 - lib/sequel/plugins/singular_table_names.rb
 - lib/sequel/plugins/skip_create_refresh.rb
@@ -451,7 +453,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []