sequel 5.103.0 → 5.105.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 955bca9c729dcd1f54079d4d48d7ac162b6d7e2b234857cfd80d228117541e5a
-  data.tar.gz: fe96ad60b73bd55cbaec0f62ba0b977cb79a7ba23fa33a392116b54ca5e7ef34
+  metadata.gz: aa9e8681d693c24d9f5dc7f6369be50dfcbf73c648402ec486e9ba69d5792f76
+  data.tar.gz: 7de020c93e5388ea9d58bd6e4d601bd06b240684e4c9001985549fd3b1c2d665
 SHA512:
-  metadata.gz: 783fa47d72067acb98193be788f133891839984441d0ca763c6be92421b99d294c1710b52e7538a1725fe476bd17b16a1796f68d96017f3e07ef12cc34a2181e
-  data.tar.gz: 38f08e76546e3cfee1fa4c520b9d524b1558608572532a940ab06c57ddb50b2ec7766978ab020d9754af415fbd679383d44a506018cca141c0c46ba9f62271cc
+  metadata.gz: 34030c2c1a045fa5fc36a6a36e1414960315469d415be97c3734fea182e63224c86c0882fa1958d5549f77c420879f6402af61a1756a4b7575a315ceb9c67f11
+  data.tar.gz: ea08def92c00668ca1898eac5a3dd37b50aeb1f81379e7c3ab19544e01cc5ef0c0c54786fc2a76f885e14b71534a3895451f33891cb374b3a3f10c08b0244d8a

data/lib/sequel/extensions/connection_expiration.rb

@@ -46,8 +46,10 @@ module Sequel
     # Initialize the data structures used by this extension.
     def self.extended(pool)
       case pool.pool_type
-      when :single, :sharded_single
-        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool"
+      when :threaded, :sharded_threaded, :timed_queue, :sharded_timed_queue
+        nil
+      else
+        raise Error, "cannot load connection_expiration extension if using single or sharded_single connection pool (or other unsupported connection pool)"
       end
 
       pool.instance_exec do
@@ -55,6 +57,39 @@ module Sequel
           @connection_expiration_timestamps ||= {}
           @connection_expiration_timeout ||= 14400
           @connection_expiration_random_delay ||= 0
+
+          # Record an expiration timestamp for any connections that already
+          # exist in the pool, so that a connection opened before the extension
+          # was loaded (e.g. via Sequel.connect) will eventually be expired.
+          register = method(:register_connection_expiration_time)
+
+          case pool_type
+          when :timed_queue, :sharded_timed_queue
+            register_queued_connections = lambda do |queue|
+              conns = []
+              while conn = queue.pop(timeout: 0)
+                conns << conn
+              end
+              conns.each do |conn|
+                queue.push(register_connection_expiration_time(conn))
+              end
+            end
+          end
+
+          case pool_type
+          when :threaded
+            @available_connections.each(&register)
+            @allocated.each_value(&register)
+          when :sharded_threaded
+            @available_connections.each_value{|conns| conns.each(&register)}
+            @allocated.each_value{|threads| threads.each_value(&register)}
+          when :timed_queue
+            register_queued_connections.call(@queue)
+            @allocated.each_value(&register)
+          else # when :sharded_timed_queue
+            @queues.each_value(&register_queued_connections)
+            @allocated.each_value{|threads| threads.each_value(&register)}
+          end
         end
       end
     end
@@ -69,8 +104,12 @@ module Sequel
 
     # Record the time the connection was created.
     def make_new(*)
-      conn = super
-      @connection_expiration_timestamps[conn] = [Sequel.start_timer, @connection_expiration_timeout + (rand * @connection_expiration_random_delay)].freeze
+      register_connection_expiration_time(super)
+    end
+
+    # Record an expiration entry for a connection, returns the connection.
+    def register_connection_expiration_time(conn)
+      @connection_expiration_timestamps[conn] ||= [Sequel.start_timer, @connection_expiration_timeout + (rand * @connection_expiration_random_delay)].freeze
       conn
     end
 

data/lib/sequel/model/associations.rb

@@ -112,6 +112,8 @@ module Sequel
         # the dataset unmodified if no SQL limit strategy is needed.
         def apply_eager_graph_limit_strategy(strategy, ds)
           case strategy
+          when :lateral_subquery
+            apply_lateral_subquery_eager_graph_limit_strategy(ds)
           when :distinct_on
             apply_distinct_on_eager_limit_strategy(ds.order_prepend(*self[:order]))
           when :window_function
@@ -298,7 +300,12 @@ module Sequel
             # Correlated subqueries are not supported for regular eager loading
             strategy = :ruby if strategy == :correlated_subquery
             strategy = nil if strategy == :ruby && assign_singular?
-            objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
+
+            objects = if strategy == :lateral_subquery
+              apply_lateral_subquery_eager_limit_strategy(ds, ids, eager_limit).all
+            else
+              apply_eager_limit_strategy(ds, strategy, eager_limit).all
+            end
 
             if strategy == :window_function
               delete_rn = ds.row_number_column 
@@ -366,7 +373,12 @@ module Sequel
         # filtered.  Works by using a subquery to test that the objects passed
         # also meet the association filter criteria.
         def filter_by_associations_conditions_expression(obj)
-          ds = filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj))
+          ds = if filter_by_associations_limit_strategy == :lateral_subquery
+            apply_lateral_subquery_filter_limit_strategy(associated_eager_dataset, obj)
+          else
+            filter_by_associations_conditions_dataset.where(filter_by_associations_conditions_subquery_conditions(obj))
+          end
+
           {filter_by_associations_conditions_key=>ds}
         end
 
@@ -754,6 +766,61 @@ module Sequel
           end
         end
 
+        def lateral_subquery_eager_limit_strategy_lateral_dataset(ds, limit_and_offset)
+          ds.
+            where(Array(filter_by_associations_conditions_key).zip(Array(filter_by_associations_conditions_associated_keys))).
+            limit(*limit_and_offset).
+            lateral
+        end
+
+        def apply_lateral_subquery_eager_limit_strategy(ds, ids, limit_and_offset)
+          table_name = self[:model].table_name
+          associated_table_name = associated_class.table_name
+
+          associated_class.
+            from(table_name).
+            select_all(associated_table_name).
+            join(lateral_subquery_eager_limit_strategy_lateral_dataset(ds, limit_and_offset).as(associated_table_name), true).
+            order(*self[:order])
+        end
+
+        # Return an expression to filter the filter by associations dataset to only
+        # rows related to given objects.
+        def _lateral_subquery_filter_limit_strategy_conditions(obj, key, value_method, value_column)
+          value = case obj
+          when Array
+            if key.is_a?(Array)
+              key_methods = Array(value_method)
+              obj.map{|o| key_methods.map{|meth| o.send(meth)}}
+            else
+              obj.map{|o| o.send(value_method)}
+            end
+          when Sequel::Dataset
+            obj.select(*Array(qualify(associated_class.table_name, value_column)))
+          else
+            if key.is_a?(Array)
+              return Array(key).zip(Array(value_method).map{|meth| obj.send(meth)})
+            else
+              obj.send(value_method)
+            end
+          end
+
+          {key => value}
+        end
+
+        def lateral_subquery_filter_limit_strategy_lateral_dataset(ds, obj)
+          lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds.
+            select(*qualify(associated_class.table_name, associated_class.primary_key)).
+            limit(*limit_and_offset).
+            lateral)
+        end
+
+        def apply_lateral_subquery_filter_limit_strategy(ds, obj)
+          lateral_subquery_filter_limit_strategy_filter_dataset(self[:model].
+            select(*lateral_subquery_filter_limit_strategy_lateral_dataset_select).
+            join(lateral_subquery_filter_limit_strategy_lateral_dataset(ds, obj).as(associated_class.table_name), filter_by_associations_conditions_subquery_conditions(obj)), obj)
+        end
+
         # Whether to limit the associated dataset to a single row.
         def limit_to_single_row?
           !returns_array?
@@ -776,7 +843,12 @@ module Sequel
                 end
               end
 
-              apply_eager_limit_strategy(ds.where(predicate_key=>arg), eager_limit_strategy)
+              strategy = eager_limit_strategy
+              if strategy == :lateral_subquery
+                apply_lateral_subquery_eager_limit_strategy(ds, arg, limit_and_offset)
+              else
+                apply_eager_limit_strategy(ds.where(predicate_key=>arg), strategy)
+              end
             end
           end
         end
@@ -1018,7 +1090,7 @@ module Sequel
       class OneToManyAssociationReflection < AssociationReflection
         ASSOCIATION_TYPES[:one_to_many] = self
         
-        # Support a correlated subquery limit strategy when using eager_graph.
+        # Support a lateral_subquery and correlated_subquery limit strategy when using eager_graph.
         def apply_eager_graph_limit_strategy(strategy, ds)
           case strategy
           when :correlated_subquery
@@ -1118,6 +1190,54 @@ module Sequel
           ds.where(qualify(table_alias, primary_key)=>cs)
         end
 
+        # Use a LATERAL subquery to limit the dataset.  Note that this will not
+        # work correctly if the associated dataset uses qualified identifers in the WHERE clause,
+        # as they would reference the containing query instead of the subquery.
+        #
+        # This does not contain the conditions that are necessary to join to the
+        # query, since the necessary qualifier is not passed as an argument.
+        def apply_lateral_subquery_eager_graph_limit_strategy(ds)
+          table_name = ds.first_source_alias
+          qualifier = ds.opts[:eager_options][:implicit_qualifier]
+          graph_conditions = self[:_graph_conditions]
+
+          unless Sequel.condition_specifier?(graph_conditions)
+            raise Error, "lateral_subquery eager graph limit strategy only supported when graph conditions are a hash or array of pairs"
+          end
+
+          ds.
+            limit(*limit_and_offset).
+            order(*self[:order]).
+            where(graph_conditions.map{|k, v| [qualify(table_name, k), qualify(qualifier, v)]}).
+            lateral
+        end
+
+        # Avoid setting duplicate predicate condition when using the lateral subquery
+        # eager limit strategy.
+        def eager_loading_set_predicate_condition(ds, eo)
+          eager_limit_strategy == :lateral_subquery ? ds : super
+        end
+
+        def apply_lateral_subquery_eager_limit_strategy(ds, ids, limit_and_offset)
+          super.where(qualify(self[:model].table_name, self[:primary_key]) => ids)
+        end
+
+        def lateral_subquery_filter_limit_strategy_conditions(obj)
+          _lateral_subquery_filter_limit_strategy_conditions(obj, filter_by_associations_conditions_key, self[:key_method], self[:key])
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds)
+          ds.where(Array(filter_by_associations_conditions_key).zip(Array(filter_by_associations_conditions_associated_keys)))
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_dataset(ds, obj)
+          ds.where(lateral_subquery_filter_limit_strategy_conditions(obj))
+        end
+
+        def lateral_subquery_filter_limit_strategy_lateral_dataset_select
+          qualified_primary_key
+        end
+
         # Support correlated subquery strategy when filtering by limited associations.
         def apply_filter_by_associations_limit_strategy(ds)
           case filter_by_associations_limit_strategy
@@ -1432,6 +1552,52 @@ module Sequel
           end
         end
 
+        def lateral_subquery_filter_limit_strategy_conditions(obj)
+          _lateral_subquery_filter_limit_strategy_conditions(obj, lateral_subquery_filter_limit_strategy_conditions_key, right_primary_key_method, right_primary_key)
+        end
+
+        def lateral_subquery_filter_limit_strategy_conditions_key
+          self[:right_key]
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds)
+          ds.where(Array(filter_by_associations_conditions_key).zip(Array(filter_by_associations_conditions_associated_keys)))
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_dataset(ds, obj)
+          ds.where(filter_by_associations_conditions_key => ds.db.from(self[:join_table]).
+            select(*self[:left_key]).
+            where(lateral_subquery_filter_limit_strategy_conditions(obj)))
+        end
+
+        def lateral_subquery_filter_limit_strategy_lateral_dataset_select
+          qualify(self[:model].table_name, self[:left_primary_key])
+        end
+
+        def lateral_subquery_eager_limit_strategy_lateral_dataset(ds, limit_and_offset)
+          ds = super
+          select = ds.opts[:select].dup
+          left_key_alias = self[:left_key_alias]
+          select.pop while (s = select.last).is_a?(Sequel::SQL::AliasedExpression) && (left_key_alias.is_a?(Array) ? left_key_alias.include?(s.alias) : s.alias == left_key_alias)
+          ds = ds.clone(:select=>select)
+        end
+
+        def apply_lateral_subquery_eager_limit_strategy(ds, ids, limit_and_offset)
+          table_name = self[:model].table_name
+          super.
+            select_all(associated_class.table_name).
+            select_append(*qualify(table_name, self[:left_primary_keys]).zip(Array(self[:left_key_alias])).map{|id, aliaz| Sequel.as(id, aliaz)}).
+            where(qualify(table_name, self[:left_primary_key]) => ids)
+        end
+
+        def apply_lateral_subquery_eager_graph_limit_strategy(ds)
+          ds.
+            limit(*limit_and_offset).
+            where(qualify(join_table_alias, self[:left_keys]).zip(qualify(ds.opts[:eager_options][:implicit_qualifier], self[:left_primary_key_columns]))).
+            order(*self[:order]).
+            lateral
+        end
+
         # Use the right_keys from the eager loading options if
         # using a separate query per table.
         def eager_loading_set_predicate_condition(ds, eo)
@@ -2008,6 +2174,7 @@ module Sequel
           associate(:one_to_one, name, opts, &block)
         end
 
+        Plugins.model_instance_variables(self, :@associations, :@set_associated_object_if_same)
         Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@default_association_type_options=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
@@ -2413,9 +2580,14 @@ module Sequel
           conditions = opts[:graph_conditions]
           opts[:cartesian_product_number] ||= one_to_one ? 0 : 1
           graph_block = opts[:graph_block]
+          graph_conditions = opts[:_graph_conditions] = use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(opts.apply_eager_graph_limit_strategy(eo[:limit_strategy], eager_graph_dataset(opts, eo)), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
+            graph_limit_strategy = eo[:limit_strategy]
+            egds = opts.apply_eager_graph_limit_strategy(graph_limit_strategy, eager_graph_dataset(opts, eo))
+            graph_conditions_true = true if graph_limit_strategy == :lateral_subquery
+
+            ds = ds.graph(egds, graph_conditions_true || graph_conditions, eo.merge(:select=>select, :join_type=>eo[:join_type]||join_type, :qualify=>:deep), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -2498,6 +2670,9 @@ module Sequel
         # Return dataset to graph into given the association reflection, applying the :callback option if set.
         def eager_graph_dataset(opts, eager_options)
           ds = opts.associated_class.dataset
+          if eager_options[:limit_strategy] == :lateral_subquery
+            ds = ds.clone(:eager_options=>eager_options)
+          end
           if opts[:graph_use_association_block] && (b = opts[:block])
             ds = b.call(ds)
           end

data/lib/sequel/model/base.rb

@@ -84,6 +84,10 @@ 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
@@ -221,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
@@ -501,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)
@@ -631,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
@@ -665,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.
       #
@@ -814,6 +835,60 @@ 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
+
+        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
       # via the database if that will return inaccurate results or if
       # it raises an error.
@@ -937,6 +1012,7 @@ END
           :@require_valid_table=>nil,
           :@restrict_primary_key=>nil,
           :@setter_methods=>nil,
+          :@shape_friendly=>nil,
           :@simple_pk=>nil,
           :@simple_table=>nil,
           :@strict_param_setting=>nil,
@@ -1094,7 +1170,7 @@ END
       # 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
 
@@ -1135,13 +1211,23 @@ END
       #   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
@@ -1445,7 +1531,7 @@ END
       #   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.
@@ -2337,6 +2423,7 @@ END
 
     extend ClassMethods
     plugin self
+    def_initialize_nil_instance_variables
 
     singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
     # :nocov:

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/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

@@ -66,6 +66,8 @@ module Sequel
       end
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@compositions)
+
         # A hash with composition name keys and composition reflection
         # hash values.
         attr_reader :compositions

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

data/lib/sequel/plugins/forbid_lazy_load.rb

@@ -118,6 +118,7 @@ module Sequel
       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

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/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

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

@@ -162,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
 

data/lib/sequel/plugins/many_through_many.rb

@@ -146,6 +146,27 @@ module Sequel
           ds
         end
 
+        def lateral_subquery_filter_limit_strategy_conditions_key
+          qualify(reverse_edges.first[:table], reverse_edges.first[:left])
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds)
+          ds.where(Array(qualify(edges.first[:table], edges.first[:right])).zip(Array(qualify(self[:model].table_name, edges.first[:left]))))
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_dataset(ds, obj)
+          first_edge, *remaining_edges = edges
+          filter_ds = ds.db.from(first_edge[:table]).
+            select(*qualify(first_edge[:table], first_edge[:right])).
+            where(lateral_subquery_filter_limit_strategy_conditions(obj))
+
+          remaining_edges.each do |edge|
+            filter_ds = filter_ds.join(edge[:table], Array(edge[:right]).zip(Array(edge[:left])))
+          end
+
+          ds.where(qualify(self[:model].table_name, self[:left_primary_key]) => filter_ds)
+        end
+
         # Make sure to use unique table aliases when lazy loading or eager loading
         def calculate_reverse_edge_aliases(reverse_edges)
           aliases = [associated_class.table_name]

data/lib/sequel/plugins/modification_detection.rb

@@ -34,6 +34,8 @@ module Sequel
     #   Album.plugin :modification_detection
     module ModificationDetection
       module ClassMethods
+        Plugins.model_instance_variables(self, :@values_hashes)
+
         # Calculate the hashes for all of the column values, so that they
         # can be compared later to determine if the column value has changed.
         def call(_)

data/lib/sequel/plugins/serialization.rb

@@ -113,6 +113,8 @@ module Sequel
       register_format(:json, Sequel.method(:object_to_json), Sequel.method(:parse_json))
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@deserialized_values)
+
         # A hash with column name symbols and callable values, with the value
         # called to deserialize the column.
         attr_reader :deserialization_map

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -30,6 +30,10 @@ module Sequel
       def self.apply(model)
         model.plugin :serialization
       end
+
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@original_deserialized_values)
+      end
       
       module InstanceMethods
         # Clear the cache of original deserialized values after saving so that it doesn't

data/lib/sequel/plugins/split_values.rb

@@ -36,6 +36,8 @@ module Sequel
     #   Album.plugin :split_values
     module SplitValues
       module ClassMethods
+        Plugins.model_instance_variables(self, :@noncolumn_values)
+
         # Split the noncolumn values when creating a new object retrieved from
         # the database.
         def call(_)

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -124,6 +124,10 @@ module Sequel
     #   # Make the Album class use tactical eager loading
     #   Album.plugin :tactical_eager_loading
     module TacticalEagerLoading
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@retrieved_by, :@retrieved_with)
+      end
+
       module InstanceMethods
         # The dataset that retrieved this object, set if the object was
         # reteived via Dataset#all.

data/lib/sequel/plugins/update_primary_key.rb

@@ -22,6 +22,10 @@ module Sequel
     #   # Make the Album class support primary key updates
     #   Album.plugin :update_primary_key
     module UpdatePrimaryKey
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@pk_hash)
+      end
+
       module InstanceMethods
         # Clear the cached primary key.
         def after_update

data/lib/sequel/plugins/validation_contexts.rb

@@ -29,6 +29,10 @@ module Sequel
     # of that model, you can no longer specify a validation context when
     # validating the instance.
     module ValidationContexts
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@validation_context)
+      end
+
       module InstanceMethods 
         # The validation context to use for the current validation.
         # Set via the :validation_context option passed to save/valid?.

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 = 103
+  MINOR = 105
 
   # 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.103.0
+  version: 5.105.0
 platform: ruby
 authors:
 - Jeremy Evans
@@ -455,7 +455,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []