sequel 5.83.0 → 5.106.0

data/lib/sequel/plugins/constraint_validations.rb

@@ -113,7 +113,7 @@ module Sequel
         def parse_constraint_validations
           db.extension(:_model_constraint_validations)
 
-          unless hash = Sequel.synchronize{db.constraint_validations}
+          unless Sequel.synchronize{db.constraint_validations}
             hash = {}
             db.from(constraint_validations_table).each do |r|
               (hash[r[:table]] ||= []) << r
@@ -121,14 +121,7 @@ module Sequel
             Sequel.synchronize{db.constraint_validations = hash}
           end
 
-          if @dataset
-            ds = @dataset.with_quote_identifiers(false)
-            table_name = ds.literal(ds.first_source_table)
-            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
+          parse_constraint_validations_dataset if @dataset
         end
 
         # Given a specific database constraint validation metadata row hash, transform
@@ -164,7 +157,7 @@ module Sequel
             arg = constraint_validation_int_range(arg)
             type = :includes
           when *OPERATOR_MAP.keys
-            arg = arg.to_i if type.to_s =~ /\Aint_/
+            arg = arg.to_i if type.to_s.start_with?('int_')
             operator = OPERATOR_MAP[type]
             type = :operator
           end
@@ -236,6 +229,18 @@ module Sequel
             Regexp.new(arg)
           end
         end
+
+        # If this model has associated dataset, use the model's table name
+        # to get the validations for just this model.
+        def parse_constraint_validations_dataset
+          ds = @dataset.with_quote_identifiers(false)
+          table_name = ds.literal(ds.first_source_table)
+          reflections = {}
+          allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+          hash = Sequel.synchronize{db.constraint_validations}
+          @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
+          @constraint_validation_reflections = reflections
+        end
       end
 
       module InstanceMethods

data/lib/sequel/plugins/dataset_associations.rb

@@ -82,8 +82,27 @@ module Sequel
         # database supports window functions.
         def associated(name)
           raise Error, "unrecognized association name: #{name.inspect}" unless r = model.association_reflection(name)
-          ds = r.associated_class.dataset
+          klass = r.associated_class
           sds = opts[:limit] ? self : unordered
+
+          if r.send(:filter_by_associations_limit_strategy) == :lateral_subquery
+            ds = r.send(:associated_eager_dataset)
+
+            case r[:type]
+            when :one_to_one, :one_to_many
+              sds = sds.select(*Array(r.qualified_primary_key))
+            else
+              sds = sds.select(*r[:left_primary_keys])
+              ds = ds.select_all(klass.table_name)
+              update_select = true
+            end
+
+            ds = r.send(:apply_lateral_subquery_eager_limit_strategy, ds, sds, r.limit_and_offset)
+            ds = ds.clone(:select=>ds.opts[:select][0,1]) if update_select
+            return ds.clone(:eager=>nil, :eager_graph=>nil)
+          end
+
+          ds = klass.dataset
           ds = case r[:type]
           when :many_to_one
             ds.where(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))

data/lib/sequel/plugins/deprecated_associations.rb

@@ -0,0 +1,151 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The deprecated_associations plugin adds support for
+    # deprecating associations. Attempts to use association
+    # methods and access association metadata for deprecated
+    # associations results in a warning.
+    #
+    #   Album.plugin :deprecated_associations
+    #   Album.many_to_one :artist, deprecated: true
+    #   album = Album[1]
+    #
+    #   # Warnings for all of the following calls
+    #   album.artist
+    #   album.artist_dataset
+    #   album.artist = Artist[2]
+    #   Album.association_reflection(:artist)
+    #   Album.eager(:artist)
+    #   Album.eager_graph(:artist)
+    #   Album.where(artist: Artist[1]).all
+    #
+    # By default, the plugin issues a single warning per
+    # association method or association reflection. See
+    # DeprecatedAssociations.configure for options to make
+    # deprecated association issue warnings for every access,
+    # to include backtraces in warnings, or to raise an
+    # exception instead of warning.
+    #
+    # Note that Model.association_reflections and
+    # Model.all_association_reflections will include deprecated
+    # associations, and accessing the metadata for deprecated
+    # associations through these interfaces not issue warnings.
+    #
+    # Usage:
+    #
+    #   # Make all models support deprecated associations
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :deprecated_associations
+    #
+    #   # Make Album class support deprecated associations
+    #   Album.plugin :deprecated_associations
+    module DeprecatedAssociations
+      # Exception class used for deprecated association use when
+      # raising exceptions instead of emitting warnings.
+      class Access < Sequel::Error; end
+
+      # Configure the deprecated associations plugin. Options:
+      #
+      # backtrace: Print backtrace with warning
+      # deduplicate: Set to false to emit warnings for every
+      #              deprecated association method call/access
+      #              (when not caching associations, this is always false)
+      # raise: Raise Sequel::Plugin::DeprecatedAssociations::Access
+      #        instead of warning
+      def self.configure(model, opts = OPTS)
+        model.instance_exec do
+          (@deprecated_associations_config ||= {}).merge!(opts)
+        end
+      end
+
+      module ClassMethods
+        # Issue a deprecation warning if the association is deprecated.
+        def association_reflection(assoc)
+          ref = super
+          if ref && ref[:deprecated]
+            emit_deprecated_association_warning(ref, nil) do
+              "Access of association reflection for deprecated association: class:#{name} association:#{assoc}"
+            end
+          end
+          ref
+        end
+
+        private
+
+        # Issue a deprecation warning when the defined method is called if the
+        # association is deprecated and the method name does not start with the
+        # underscore (to avoid not warning twice, once for the public association
+        # method and once for the private association method).
+        def association_module_def(name, opts=OPTS, &block)
+          super
+          if opts[:deprecated] && name[0] != "_"
+            deprecated_associations_module.module_exec do
+              define_method(name) do |*a, &b|
+                self.class.send(:emit_deprecated_association_warning, opts, name) do
+                  "Calling deprecated association method: class:#{self.class.name} association:#{opts[:name]} method:#{name}"
+                end
+                super(*a, &b)
+              end
+              alias_method name, name
+            end
+          end
+          nil
+        end
+
+        # Issue a deprecation warning when the defined method is called if the
+        # association is deprecated.
+        def association_module_delegate_def(name, opts, &block)
+          super
+          if opts[:deprecated]
+            deprecated_associations_module.module_exec do
+              define_method(name) do |*a, &b|
+                self.class.send(:emit_deprecated_association_warning, opts, name) do
+                  "Calling deprecated association method: class:#{self.class.name} association:#{opts[:name]} method:#{name}"
+                end
+                super(*a, &b)
+              end
+              # :nocov:
+              ruby2_keywords(name) if respond_to?(:ruby2_keywords, true)
+              # :nocov:
+              alias_method(name, name)
+            end
+          end
+          nil
+        end
+
+        # A module to add deprecated association methods to. These methods
+        # handle issuing the deprecation warnings, and call super to get the
+        # default behavior.
+        def deprecated_associations_module
+          return @deprecated_associations_module if defined?(@deprecated_associations_module)
+          @deprecated_associations_module = Module.new
+          include(@deprecated_associations_module)
+          @deprecated_associations_module
+        end
+
+        # Emit a deprecation warning, or raise an exception if the :raise
+        # plugin option was used.
+        def emit_deprecated_association_warning(ref, method)
+          config = @deprecated_associations_config
+
+          raise Access, yield if config[:raise]
+
+          unless config[:deduplicate] == false
+            emit = false
+            ref.send(:cached_fetch, [:deprecated_associations, method]) do
+              emit = true
+            end
+            return unless emit
+          end
+
+          if config[:backtrace]
+            warn yield, caller(2)
+          else
+            warn yield, :uplevel => 2
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -63,6 +63,10 @@ module Sequel
     #   # Make the Album class record previous values
     #   Album.plugin :dirty
     module Dirty
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@previous_changes, :@initial_values, :@missing_initial_values)
+      end
+
       module InstanceMethods
         # A hash of previous changes before the object was
         # saved, in the same format as #column_changes.
@@ -234,8 +238,11 @@ module Sequel
               iv.delete(column)
             end
           else
-            check_missing_initial_value(column)
-            iv[column] = get_column_value(column)
+            if db_schema[column]
+              check_missing_initial_value(column)
+              iv[column] = get_column_value(column)
+            end
+
             super
           end
         end

data/lib/sequel/plugins/enum.rb

@@ -80,7 +80,7 @@ module Sequel
           inverted = values.invert.freeze
 
           unless @enum_methods
-            @enum_methods = Module.new
+            @enum_methods = Sequel.set_temp_name(Module.new){"#{name}::@enum_methods"}
             include @enum_methods
           end
 

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,13 +101,24 @@ 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
       end
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@forbid_lazy_load)
         Plugins.def_dataset_methods(self, :forbid_lazy_load)
 
         # If the static_cache plugin is used by the associated class for
@@ -179,7 +193,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/insert_conflict.rb

@@ -42,6 +42,10 @@ module Sequel
         end
       end
 
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@insert_conflict_opts)
+      end
+
       module InstanceMethods
         # Set the insert_conflict options to pass to the dataset when inserting. 
         def insert_conflict(opts=OPTS)

data/lib/sequel/plugins/insert_returning_select.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # If the model's dataset selects explicit columns and the
+    # If the model's dataset selects explicit columns (or table.*) and the
     # database supports it, the insert_returning_select plugin will
     # automatically set the RETURNING clause on the dataset used to
     # insert rows to the columns selected, which allows the default model
@@ -45,6 +45,9 @@ module Sequel
           ret
         end
 
+        RETURN_ALL = [Sequel::Dataset::WILDCARD].freeze
+        private_constant :RETURN_ALL
+
         # Determine the columns to use for the returning clause, or return nil
         # if they can't be determined and a returning clause should not be
         # added automatically.
@@ -52,6 +55,12 @@ module Sequel
           return unless ds.supports_returning?(:insert)
           return unless values = ds.opts[:select]
 
+          # SELECT table.* -> RETURNING *
+          if values.length == 1 && values[0].is_a?(Sequel::SQL::ColumnAll)
+            return RETURN_ALL
+          end
+
+          # SELECT column1, table.column2, ... -> RETURNING column1, column2, ...
           values = values.map{|v| ds.unqualified_column_for(v)}
           if values.all?
             values

data/lib/sequel/plugins/inspect_pk.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The inspect_pk plugin includes the pk right next to the
+    # model name in inspect, allowing for easily copying and
+    # pasting to retrieve a copy of the object:
+    #
+    #   Album.with_pk(1).inspect
+    #   #         default: #<Album @values={...}>
+    #   # with inspect_pk: #<Album[1] @values={...}>
+    #
+    # Usage:
+    #
+    #   # Make all model instances include pk in inspect output
+    #   Sequel::Model.plugin :inspect_pk
+    #
+    #   # Make Album instances include pk in inspect output
+    #   Album.plugin :inspect_pk
+    module InspectPk
+      module InstanceMethods
+        private
+
+        # The primary key value to include in the inspect output, if any.
+        # For composite primary keys, this only includes a value if all
+        # fields are present.
+        def inspect_pk
+          if primary_key && (pk = self.pk) && (!(Array === pk) || pk.all?)
+            pk
+          end
+        end
+
+        # Include the instance's primary key in the output.
+        def inspect_prefix
+          if v = inspect_pk
+            "#{super}[#{v.inspect}]"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/instance_filters.rb

@@ -50,6 +50,10 @@ module Sequel
         model.require_modification = true
       end
 
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@instance_filters)
+      end
+
       module InstanceMethods
         # Clear the instance filters after successfully destroying the object.
         def after_destroy
@@ -102,7 +106,10 @@ module Sequel
         
         # Apply the instance filters to the given dataset
         def apply_instance_filters(ds)
-          instance_filters.inject(ds){|ds1, i| ds1.where(*i[0], &i[1])}
+          instance_filters.inject(ds) do |ds1, i|
+            block = i[1]
+            ds1.where(*i[0], &block)
+          end
         end
         
         # Clear the instance filters.

data/lib/sequel/plugins/instance_hooks.rb

@@ -28,6 +28,10 @@ module Sequel
     #   # Add the instance hook methods just to Album instances
     #   Album.plugin :instance_hooks
     module InstanceHooks
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@instance_hooks)
+      end
+
       module InstanceMethods 
         Sequel::Model::HOOKS.each{|h| class_eval(<<-END , __FILE__, __LINE__+1)}
           def #{h}_hook(&block)

data/lib/sequel/plugins/inverted_subsets.rb

@@ -32,6 +32,7 @@ module Sequel
       def self.apply(model, &block)
         model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
+            Sequel.set_temp_name(self){"#{model.name}::@dataset_module_class(InvertedSubsets)"}
             include DatasetModuleMethods
             if block
               define_method(:inverted_subset_name, &block)

data/lib/sequel/plugins/json_serializer.rb

@@ -106,13 +106,7 @@ module Sequel
     # and breaks some aspects of the json_serializer plugin.  You can undo the damage
     # done by active_support/json by doing:
     #
-    #   module ActiveSupportBrokenJSONFix
-    #     def to_json(options = {})
-    #       JSON.generate(self)
-    #     end
-    #   end
-    #   Array.send(:prepend, ActiveSupportBrokenJSONFix)
-    #   Hash.send(:prepend, ActiveSupportBrokenJSONFix)
+    #   ActiveSupport::ToJsonWithActiveSupportEncoder.send(:remove_method, :to_json)
     #
     # Note that this will probably cause active_support/json to no longer work
     # correctly in some cases.
@@ -168,6 +162,8 @@ module Sequel
       end
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@json_serializer_opts)
+
         # The default opts to use when serializing model objects to JSON.
         attr_reader :json_serializer_opts
 
@@ -370,9 +366,9 @@ module Sequel
         end
 
         # Convert the receiver to a JSON data structure using the given arguments.
-        def to_json_data(*args, &block)
-          if block
-            to_json(*args){|x| return block.call(x)}
+        def to_json_data(*args)
+          if defined?(yield)
+            to_json(*args){|x| return yield(x)}
           else
             to_json(*args){|x| return x}
           end

data/lib/sequel/plugins/lazy_attributes.rb

@@ -64,7 +64,7 @@ module Sequel
         # :dataset :: The base dataset to use for the lazy attribute lookup
         # :table :: The table name to use to qualify the attribute and primary key columns.
         def define_lazy_attribute_getter(a, opts=OPTS)
-          include(@lazy_attributes_module ||= Module.new) unless @lazy_attributes_module
+          include(@lazy_attributes_module ||= Sequel.set_temp_name(Module.new){"#{name}::@lazy_attributes_module"}) unless @lazy_attributes_module
           @lazy_attributes_module.class_eval do
             define_method(a) do
               if !values.has_key?(a) && !new?