sequel 5.83.0 → 5.106.0

data/lib/sequel/model/base.rb

@@ -2,13 +2,15 @@
 
 module Sequel
   class Model
+    # SEQUEL6: Remove Enumerable here, and send all Enumerable methods to dataset
+    # by default, with a plugin for the current behavior.
     extend Enumerable
     extend Inflections
 
     # Class methods for Sequel::Model that implement basic model functionality.
     #
     # * All of the following methods have class methods created that send the method
-    #   to the model's dataset: all, as_hash, avg, count, cross_join, distinct, each,
+    #   to the model's dataset: all, any?, as_hash, as_set, avg, count, cross_join, distinct, each,
     #   each_server, empty?, except, exclude, exclude_having, fetch_rows,
     #   filter, first, first!, for_update, from, from_self, full_join, full_outer_join,
     #   get, graph, grep, group, group_and_count, group_append, group_by, having, import,
@@ -17,7 +19,7 @@ module Sequel
     #   natural_join, natural_left_join, natural_right_join, offset, order, order_append, order_by,
     #   order_more, order_prepend, paged_each, qualify, reverse, reverse_order, right_join,
     #   right_outer_join, select, select_all, select_append, select_group, select_hash,
-    #   select_hash_groups, select_map, select_more, select_order_map, select_prepend, server,
+    #   select_hash_groups, select_map, select_more, select_order_map, select_prepend, select_set, server,
     #   single_record, single_record!, single_value, single_value!, sum, to_hash, to_hash_groups,
     #   truncate, unfiltered, ungraphed, ungrouped, union, unlimited, unordered, where, where_all,
     #   where_each, where_single_value, with, with_recursive, with_sql
@@ -82,12 +84,16 @@ module Sequel
       # underlying table doesn't exist.
       attr_accessor :require_valid_table
 
+      # Whether the model uses a shape friendly design (initializing all potentially
+      # used instance variables to nil).
+      attr_reader :shape_friendly
+
       # Should be the literal primary key column name if this Model's table has a simple primary key, or
       # nil if the model has a compound primary key or no primary key.
       attr_reader :simple_pk
   
       # Should be the literal table name if this Model's dataset is a simple table (no select, order, join, etc.),
-      # or nil otherwise.  This and simple_pk are used for an optimization in Model.[].
+      # or nil otherwise.  This and simple_pk are used for an optimization in Model[].
       attr_reader :simple_table
   
       # Whether mass assigning via .create/.new/#set/#update should raise an error
@@ -184,7 +190,7 @@ module Sequel
           end
         end
 
-        klass = Class.new(self)
+        klass = Sequel.set_temp_name(Class.new(self)){"Sequel::_Model(#{source.inspect})"}
 
         if source.is_a?(::Sequel::Database)
           klass.db = source
@@ -219,9 +225,7 @@ module Sequel
       # Requires that values be a hash where all keys are symbols. It
       # probably should not be used by external code.
       def call(values)
-        o = allocate
-        o.instance_variable_set(:@values, values)
-        o
+        allocate.initialize_from_db(values)
       end
       
       # Clear the setter_methods cache
@@ -398,7 +402,7 @@ module Sequel
       end
   
       # Finds a single record according to the supplied filter.
-      # You are encouraged to use Model.[] or Model.first instead of this method.
+      # You are encouraged to use Model[] or Model.first instead of this method.
       #
       #   Artist.find(name: 'Bob')
       #   # SELECT * FROM artists WHERE (name = 'Bob') LIMIT 1
@@ -499,7 +503,13 @@ module Sequel
         unless @plugins.include?(m)
           @plugins << m
           m.apply(self, *args, &block) if m.respond_to?(:apply)
-          extend(m::ClassMethods) if m.const_defined?(:ClassMethods, false)
+          if m.const_defined?(:ClassMethods, false)
+            class_methods = m::ClassMethods
+            extend(class_methods)
+            if class_methods.private_method_defined?(:each_model_instance_variable)
+              def_initialize_nil_instance_variables
+            end
+          end
           include(m::InstanceMethods) if m.const_defined?(:InstanceMethods, false)
           if m.const_defined?(:DatasetMethods, false)
             dataset_extend(m::DatasetMethods, :create_class_methods=>false)
@@ -533,10 +543,28 @@ module Sequel
         end
       end
 
+      # Return a qualified identifier or array of qualified identifiers for
+      # the model's primary key.  Uses the given qualifier if provided, or
+      # the table_name otherwise. If the model does not have a primary key,
+      # raises an +Error+.
+      #
+      #   Artist.order(Artist.qualified_primary_key)
+      #   # SELECT * FROM artists ORDER BY artists.id
+      def qualified_primary_key(qualifier=table_name)
+        case key = @primary_key
+        when Symbol
+          SQL::QualifiedIdentifier.new(qualifier, key)
+        when Array
+          key.map{|k| SQL::QualifiedIdentifier.new(qualifier, k)}
+        else
+          raise(Error, "#{self} does not have a primary key")
+        end
+      end
+
       # Return a hash where the keys are qualified column references.  Uses the given
       # qualifier if provided, or the table_name otherwise. This is useful if you
       # plan to join other tables to this table and you want the column references
-      # to be qualified.
+      # to be qualified. If the model does not have a primary key, raises an +Error+.
       #
       #   Artist.where(Artist.qualified_primary_key_hash(1))
       #   # SELECT * FROM artists WHERE (artists.id = 1)
@@ -611,6 +639,13 @@ module Sequel
         self
       end
 
+      # Set instance variables used by instances of this model class.
+      # Only has an effect if shape_friendly is true.
+      def set_model_instance_variables(*ivs)
+        Plugins.model_instance_variables(singleton_class, *ivs)
+        def_initialize_nil_instance_variables
+      end
+
       # Sets the primary key for this model. You can use either a regular 
       # or a composite primary key.  To not use a primary key, set to nil
       # or use +no_primary_key+. On most adapters, Sequel can automatically
@@ -645,6 +680,12 @@ module Sequel
         @setter_methods || (@setter_methods = get_setter_methods)
       end
 
+      # Set whether the model should be shape friendly.
+      def shape_friendly=(v)
+        @shape_friendly = v
+        def_initialize_nil_instance_variables
+      end
+
       # Returns name of primary table for the dataset. If the table for the dataset
       # is aliased, returns the aliased name.
       #
@@ -677,7 +718,7 @@ module Sequel
       end
   
       # Add model methods that call dataset methods
-      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:each_server]) - [:<<, :or, :[], :columns, :columns!, :delete, :update, :set_graph_aliases, :add_graph_aliases])
+      Plugins.def_dataset_methods(self, (Dataset::ACTION_METHODS + Dataset::QUERY_METHODS + [:any?, :each_server]) - [:<<, :or, :[], :columns, :columns!, :delete, :update, :set_graph_aliases, :add_graph_aliases])
   
       private
       
@@ -762,22 +803,90 @@ module Sequel
           end
         end
       end
+
+      # Module that the class methods that call dataset methods are kept in.
+      # This allows the methods to be overridden and call super with the
+      # default behavior.
+      def dataset_methods_module
+        return @dataset_methods_module if defined?(@dataset_methods_module)
+        mod_name = "#{name}::@dataset_methods_module"
+        Sequel.synchronize{@dataset_methods_module ||= Sequel.set_temp_name(Module.new){mod_name}}
+        extend(@dataset_methods_module)
+        @dataset_methods_module
+      end
   
-      # Define a model method that calls the dataset method with the same name,
-      # only used for methods with names that can't be represented directly in
-      # ruby code.
+      # Define a model method that calls the dataset method with the same name.
       def def_model_dataset_method(meth)
         return if respond_to?(meth, true)
 
+        mod = dataset_methods_module
+
         if meth.to_s =~ /\A[A-Za-z_][A-Za-z0-9_]*\z/
-          instance_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+          mod.module_eval(<<END, __FILE__, __LINE__ + 1)
+def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end
+ruby2_keywords :#{meth} if respond_to?(:ruby2_keywords, true)
+END
         else
-          define_singleton_method(meth){|*args, &block| dataset.public_send(meth, *args, &block)}
+          mod.send(:define_method, meth){|*args, &block| dataset.public_send(meth, *args, &block)}
+          # :nocov:
+          mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+        mod.send(:alias_method, meth, meth)
+      end
+
+      # Defines the private _initialize_nil_instance_variables method.
+      # If shape_friendly is true, defines a method that initials the
+      # model's instance variables to nil. If shape_friendly is not
+      # true, does nothing.
+      def def_initialize_nil_instance_variables
+        if @shape_friendly
+          ivs = []
+          each_model_instance_variable do |iv|
+            unless iv.match(/\A@[a-z_][a-z0-9_]*\z/)
+              raise Error, "invalid model instance variable used"
+            end
+
+            ivs << iv
+          end
+          ivs.uniq!
+          ivs = ivs.reverse.join(" = ")
+          new_method_content = "#{ivs} = nil"
+          new_from_db_method_content = "#{ivs} = @new = @modified = nil"
         end
-        singleton_class.send(:alias_method, meth, meth)
-        # :nocov:
-        singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
-        # :nocov:
+
+        class_eval(<<-RUBY, __FILE__, __LINE__+1)
+          def _initialize_nil_instance_variables
+            #{new_method_content}
+          end
+          def _initialize_from_db_nil_instance_variables
+            #{new_from_db_method_content}
+          end
+        RUBY
+        private :_initialize_nil_instance_variables, :_initialize_from_db_nil_instance_variables
+        alias_method :_initialize_nil_instance_variables, :_initialize_nil_instance_variables
+        alias_method :_initialize_from_db_nil_instance_variables, :_initialize_from_db_nil_instance_variables
+        nil
+      end
+
+      # Yield the default model instance variables. Designed only for
+      # use by def_initialize_nil_instance_variables.
+      def each_model_instance_variable
+        [
+          :@changed_columns,
+          :@errors,
+          :@raise_on_save_failure,
+          :@raise_on_typecast_failure,
+          :@require_modification,
+          :@server,
+          :@singleton_setter_added,
+          :@skip_validation_on_next_save,
+          :@strict_param_setting,
+          :@this,
+          :@typecast_empty_string_to_nil,
+          :@typecast_on_assignment,
+          :@use_transactions,
+        ].each{|iv| yield iv}
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -903,6 +1012,7 @@ module Sequel
           :@require_valid_table=>nil,
           :@restrict_primary_key=>nil,
           :@setter_methods=>nil,
+          :@shape_friendly=>nil,
           :@simple_pk=>nil,
           :@simple_table=>nil,
           :@strict_param_setting=>nil,
@@ -943,7 +1053,10 @@ module Sequel
       # Module that the class includes that holds methods the class adds for column accessors and
       # associations so that the methods can be overridden with +super+.
       def overridable_methods_module
-        include(@overridable_methods_module = Module.new) unless @overridable_methods_module
+        return @overridable_methods_module if defined?(@overridable_methods_module)
+        mod_name = "#{name}::@overridable_methods_module"
+        Sequel.synchronize{@overridable_methods_module ||= Sequel.set_temp_name(Module.new){mod_name}}
+        include(@overridable_methods_module)
         @overridable_methods_module
       end
       
@@ -1057,7 +1170,7 @@ module Sequel
       # standard attr_writer method for modifying that instance variable.
       [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, 
         :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions].each do |meth|
-        class_eval("def #{meth}; !defined?(@#{meth}) ? (frozen? ? self.class.#{meth} : (@#{meth} = self.class.#{meth})) : @#{meth} end", __FILE__, __LINE__)
+        class_eval("def #{meth}; @#{meth}.nil? ? (frozen? ? self.class.#{meth} : (@#{meth} = self.class.#{meth})) : @#{meth} end", __FILE__, __LINE__)
         attr_writer(meth)
       end
 
@@ -1098,13 +1211,23 @@ module Sequel
       #   end
       def initialize(values = OPTS)
         @values = {}
-        @new = true
-        @modified = true
+        @new = @modified = true
+        _initialize_nil_instance_variables
+
         initialize_set(values)
         _clear_changed_columns(:initialize)
         yield self if defined?(yield)
       end
 
+      # Initialize a new record using values retrieved from a database.
+      # This should not be called directly, only via Model.call.
+      def initialize_from_db(values) # :nodoc:
+        @values = values
+        _initialize_from_db_nil_instance_variables
+
+        self
+      end
+
       # Returns value of the column's attribute.
       #
       #   Artist[1][:id] #=> 1
@@ -1311,7 +1434,7 @@ module Sequel
       # Returns a string representation of the model instance including
       # the class name and values.
       def inspect
-        "#<#{model.name} @values=#{inspect_values}>"
+        "#<#{inspect_prefix} @values=#{inspect_values}>"
       end
   
       # Returns the keys in +values+.  May not include all column names.
@@ -1323,17 +1446,16 @@ module Sequel
         @values.keys
       end
       
-      # Refresh this record using +for_update+ (by default, or the specified style when given)
+      # Refresh this record using +:update+ lock style (by default, or the specified style when given),
       # unless this is a new record.  Returns self. This can be used to make sure no other
-      # process is updating the record at the same time.
+      # process can modify the record during the transaction containing this call.  Using
+      # this method only makes sense inside transactions.
       #
       # If style is a string, it will be used directly. You should never pass a string
       # to this method that is derived from user input, as that can lead to
       # SQL injection.
       #
-      # A symbol may be used for database independent locking behavior, but
-      # all supported symbols have separate methods (e.g. for_update).
-      #
+      # A symbol may be used if the adapter supports that lock style.
       #
       #   a = Artist[1]
       #   Artist.db.transaction do
@@ -1343,7 +1465,7 @@ module Sequel
       #
       #   a = Artist[2]
       #   Artist.db.transaction do
-      #     a.lock!('FOR NO KEY UPDATE')
+      #     a.lock!(:no_key_update)
       #     a.update(name: 'B')
       #   end
       def lock!(style=:update)
@@ -1409,7 +1531,7 @@ module Sequel
       #   Artist.new.new? # => true
       #   Artist[1].new? # => false
       def new?
-        defined?(@new) ? @new : (@new = false)
+        @new || false
       end
       
       # Returns the primary key value identifying the model instance.
@@ -1465,6 +1587,20 @@ module Sequel
         refresh
       end
   
+      # Remove a key from the instances values, and return the value
+      # of the key.
+      #
+      #   a = Album[1]
+      #   a.values
+      #   # => {id: 1, artist_id: 2}
+      #   a.remove_key!(:artist_id)
+      #   # => 2
+      #   a.values
+      #   # => {id: 1}
+      def remove_key!(key)
+        @values.delete(key)
+      end
+
       # Creates or updates the record, after making sure the record
       # is valid and before hooks execute successfully. Fails if:
       #
@@ -1597,7 +1733,7 @@ module Sequel
         @skip_validation_on_next_save = true
       end
 
-      # Returns (naked) dataset that should return only this instance.
+      # Returns naked dataset that should return only the row related to this instance.
       #
       #   Artist[1].this
       #   # SELECT * FROM artists WHERE (id = 1) LIMIT 1
@@ -1994,7 +2130,12 @@ module Sequel
         set(h) unless h.empty?
       end
 
-      # Default inspection output for the values hash, overwrite to change what #inspect displays.
+      # Default inspect output for the inspect, by default, just showing the class.
+      def inspect_prefix
+        model.name
+      end
+
+      # Default inspect output for the values hash, overwrite to change what #inspect displays.
       def inspect_values
         @values.inspect
       end
@@ -2238,7 +2379,7 @@ module Sequel
       # Return the dataset ordered by the model's primary key.  This should not
       # be used if the model does not have a primary key.
       def _force_primary_key_order
-        cached_dataset(:_pk_order_ds){order(*model.primary_key)}
+        cached_dataset(:_pk_order_ds){order(*unambiguous_primary_key)}
       end
 
       # If the dataset is not already ordered, and the model has a primary key,
@@ -2266,6 +2407,15 @@ module Sequel
         end
       end
 
+      # The primary key for the dataset's model, qualified if the dataset is joined.
+      def unambiguous_primary_key
+        if joined_dataset?
+          model.qualified_primary_key
+        else
+          model.primary_key
+        end
+      end
+
       def non_sql_option?(key)
         super || key == :model
       end
@@ -2273,6 +2423,7 @@ module Sequel
 
     extend ClassMethods
     plugin self
+    def_initialize_nil_instance_variables
 
     singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
     # :nocov:
@@ -2280,5 +2431,17 @@ module Sequel
     # :nocov:
       singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
     end
+
+    # :nocov:
+    if defined?(Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER) && Sequel::Postgres::SEQUEL_PG_VERSION_INTEGER >= 11800
+      # Automatically optimize model loading when sequel/core was loaded,
+      # then sequel/adapters/postgres (with sequel_pg), then sequel/model
+      begin
+        require "sequel_pg/model"
+      rescue LoadError
+        # nothing
+      end
+    end
+    # :nocov:
   end
 end

data/lib/sequel/model/plugins.rb

@@ -38,7 +38,8 @@ module Sequel
     end
 
     # Add method to +mod+ that overrides inherited_instance_variables to include the
-    # values in this hash.
+    # values in this hash. These affects how class instance variables will be treated
+    # during subclassing.
     def self.inherited_instance_variables(mod, hash)
       mod.send(:define_method, :inherited_instance_variables) do ||
         super().merge!(hash)
@@ -46,6 +47,16 @@ module Sequel
       mod.send(:private, :inherited_instance_variables)
     end
 
+    # Sets the model instance variables used by the plugin. These instance variables
+    # will be initialized to nil for created model objects.
+    def self.model_instance_variables(mod, *ivs)
+      mod.send(:define_method, :each_model_instance_variable) do |&block|
+        super(&block)
+        ivs.each(&block)
+      end
+      mod.send(:private, :each_model_instance_variable)
+    end
+
     # Add method to +mod+ that overrides set_dataset to call the method afterward.
     def self.after_set_dataset(mod, meth)
       mod.send(:define_method, :set_dataset) do |*a|

data/lib/sequel/model.rb

@@ -55,6 +55,7 @@ module Sequel
     @require_valid_table = true
     @restrict_primary_key = true
     @setter_methods = nil
+    @shape_friendly = false
     @simple_pk = nil
     @simple_table = nil
     @strict_param_setting = true

data/lib/sequel/plugins/accessed_columns.rb

@@ -26,6 +26,10 @@ module Sequel
     #   # Make the Album instances record accessed columns
     #   Album.plugin :accessed_columns
     module AccessedColumns
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@accessed_columns)
+      end
+
       module InstanceMethods
         # Record the column access before retrieving the value.
         def [](c)

data/lib/sequel/plugins/active_model.rb

@@ -29,6 +29,8 @@ module Sequel
       module ClassMethods
         include ::ActiveModel::Naming
 
+        Plugins.model_instance_variables(self, :@destroyed, :@rollback_checker)
+
         # Cache model_name and to_partial path value before freezing.
         def freeze
           model_name
@@ -58,13 +60,10 @@ module Sequel
 
         # False if the object is new? or has been destroyed, true otherwise.
         def persisted?
-          return false if new?
-          return false if defined?(@destroyed)
+          return false if new? || @destroyed
 
-          if defined?(@rollback_checker)
-            if @rollback_checker.call
-              return false
-            end
+          if @rollback_checker && @rollback_checker.call
+            return false
           end
           
           true

data/lib/sequel/plugins/association_pks.rb

@@ -67,6 +67,8 @@ module Sequel
     #   Album.plugin :association_pks
     module AssociationPks
       module ClassMethods
+        Plugins.model_instance_variables(self, :@_association_pks)
+
         private
 
         # Define a association_pks method using the block for the association reflection 

data/lib/sequel/plugins/auto_validations.rb

@@ -131,6 +131,8 @@ module Sequel
       end
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@_skip_auto_validations)
+
         # The columns with automatic no_null_byte validations
         attr_reader :auto_validate_no_null_byte_columns
 

data/lib/sequel/plugins/class_table_inheritance_constraint_validations.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'constraint_validations'
+require_relative 'class_table_inheritance'
+
+module Sequel
+  module Plugins
+    # = Overview
+    #
+    # The class_table_inheritance_constraint_validations plugin extends the
+    # constraint_validations plugin to work correctly with the
+    # class_table_inheritance plugin. It ensures that constraint_validations
+    # are loaded from all tables in the class table inheritance hierarchy,
+    # not just the base table.
+    #
+    # = Example
+    #
+    # For example, with this hierarchy, where each model has its own table with
+    # constraint validations:
+    #
+    #       Employee
+    #      /        \
+    #   Staff     Manager
+    #                |
+    #            Executive
+    #
+    #   # Loads constraint_validations from the employees table
+    #   class Employee < Sequel::Model
+    #     plugin :class_table_inheritance
+    #     plugin :constraint_validations
+    #     plugin :class_table_inheritance_constraint_validations
+    #   end
+    #
+    #   # Loads constraint_validations from managers and employees tables
+    #   class Manager < Employee
+    #   end
+    #
+    #   # Loads constraint_validations from executives, managers, and
+    #   # employees tables
+    #   class Executive < Manager
+    #   end
+    #
+    #   # Loads constraint_validations from staff and employees tables
+    #   class Staff < Employee
+    #   end
+    module ClassTableInheritanceConstraintValidations
+      def self.apply(model)
+        unless ConstraintValidations::InstanceMethods > model && ClassTableInheritance::InstanceMethods > model
+          raise Error, "must load the constraint_validations and class_table_inheritance plugins into #{model} before loading class_table_inheritance_constraint_validations plugin"
+        end
+      end
+
+      module ClassMethods
+        private
+
+        def inherited(subclass)
+          super
+
+          # constraint_validations will parse_constraint_validations in the
+          # classes after_set_dataset hook. That runs before cti_tables are
+          # updated for subclasses in class_table_inheritance's inherited
+          # so re-parsing them here.
+          subclass.send(:parse_constraint_validations)
+        end
+
+        def parse_constraint_validations_dataset
+          reflections = {}
+          allow_missing_columns = db_schema.select{|col, sch| sch[:allow_null] == false && nil != sch[:default]}.map(&:first)
+          hash = Sequel.synchronize{db.constraint_validations}
+          cv = []
+          ds = @dataset.with_quote_identifiers(false)
+          cti_tables.each do |table_name|
+            table_name = ds.literal(table_name)
+            cv += (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections, allow_missing_columns)}
+          end
+          @constraint_validations = cv
+          @constraint_validation_reflections = reflections
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/columns_updated.rb

@@ -15,6 +15,10 @@ module Sequel
     #   # Make the Album class store the columns hash used for updating
     #   Album.plugin :columns_updated
     module ColumnsUpdated
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@columns_updated)
+      end
+
       module InstanceMethods
         private
 

data/lib/sequel/plugins/composition.rb

@@ -61,11 +61,13 @@ module Sequel
       def self.apply(model)
         model.instance_exec do
           @compositions = {}
-          include(@composition_module ||= Module.new)
+          include(@composition_module ||= Sequel.set_temp_name(Module.new){"#{name}::@composition_module"})
         end
       end
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@compositions)
+
         # A hash with composition name keys and composition reflection
         # hash values.
         attr_reader :compositions