sequel 5.80.0 → 5.92.0

data/lib/sequel/extensions/temporarily_release_connection.rb

@@ -0,0 +1,178 @@
+# frozen-string-literal: true
+#
+# The temporarily_release_connection extension adds support for temporarily
+# releasing a checked out connection back to the connection pool.  It is
+# designed for use in multithreaded transactional integration tests, allowing
+# a connection to start a transaction in one thread, but be temporarily
+# released back to the connection pool, so it can be operated on safely
+# by multiple threads inside a block. For example, the main thread could be
+# running tests that send web requests, and a separate thread running a web
+# server that is responding to those requests, and the same connection and
+# transaction would be used for both.
+#
+# To load the extension into the database:
+#
+#   DB.extension :temporarily_release_connection
+#
+# After the extension is loaded, call the +temporarily_release_connection+
+# method with the connection object to temporarily release the connection
+# back to the pool. Example:
+#
+#   DB.transaction(rollback: :always, auto_savepoint: true) do |conn|
+#     DB.temporarily_release_connection(conn) do
+#       # Other threads can operate on connection safely inside the transaction
+#       yield
+#     end
+#   end
+#
+# For sharded connection pools, the second argument to +temporarily_release_connection+
+# is respected, and specifies the server on which to temporarily release the connection.
+#
+# The temporarily_release_connection extension is only supported with the
+# threaded and timed_queue connection pools that ship with Sequel (and the sharded
+# versions of each).  To make sure that same connection object can be reacquired, it
+# is only supported if the maximum connection pool size is 1, so set the Database
+# :max_connections option to 1 if you plan to use this extension.
+#
+# If the +temporarily_release_connection+ method cannot reacquire the same connection
+# it released to the pool, it will raise a Sequel::UnableToReacquireConnectionError
+# exception.  This should only happen if the connection has been disconnected
+# while it was temporarily released.  If this error is raised, Database#transaction
+# will not rollback the transaction, since the connection object is likely no longer
+# valid, and on poorly written database drivers, that could cause the process to crash.
+#
+# Related modules: Sequel::TemporarilyReleaseConnection,
+# Sequel::UnableToReacquireConnectionError
+
+#
+module Sequel
+  # Error class raised if the connection pool does not provide the same connection
+  # object when checking a temporarily released connection out.
+  class UnableToReacquireConnectionError < Error
+  end
+
+  module TemporarilyReleaseConnection
+    module DatabaseMethods
+      # Temporarily release the connection back to the connection pool for the
+      # duration of the block.
+      def temporarily_release_connection(conn, server=:default, &block)
+        pool.temporarily_release_connection(conn, server, &block)
+      end
+
+      private
+
+      # Do nothing if UnableToReacquireConnectionError is raised, as it is
+      # likely the connection is not in a usable state.
+      def rollback_transaction(conn, opts)
+        return if UnableToReacquireConnectionError === $!
+        super
+      end
+    end
+
+    module PoolMethods
+      # Temporarily release a currently checked out connection, then yield to the block. Reacquire the same
+      # connection upon the exit of the block.
+      def temporarily_release_connection(conn, server)
+        t = Sequel.current
+        raise Error, "connection not currently checked out" unless conn.equal?(trc_owned_connection(t, server))
+
+        begin
+          trc_release(t, conn, server)
+          yield
+        ensure
+          c = trc_acquire(t, server)
+          unless conn.equal?(c)
+            raise UnableToReacquireConnectionError, "reacquired connection not the same as initial connection"
+          end
+        end
+      end
+    end
+
+    module TimedQueue
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t)
+      end
+
+      def trc_release(t, conn, server)
+        release(t)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t)
+      end
+    end
+
+    module ShardedTimedQueue
+      # Normalize the server name for sharded connection pools
+      def temporarily_release_connection(conn, server)
+        server = pick_server(server)
+        super
+      end
+
+      private
+
+      def trc_owned_connection(t, server)
+        owned_connection(t, server)
+      end
+
+      def trc_release(t, conn, server)
+        release(t, conn, server)
+      end
+
+      def trc_acquire(t, server)
+        acquire(t, server)
+      end
+    end
+
+    module ThreadedBase
+      private
+
+      def trc_release(t, conn, server)
+        sync{super}
+      end
+    end
+
+    module Threaded
+      include TimedQueue
+      include ThreadedBase
+    end
+
+    module ShardedThreaded
+      include ShardedTimedQueue
+      include ThreadedBase
+    end
+  end
+
+  trc = TemporarilyReleaseConnection
+  trc_map = {
+    :threaded => trc::Threaded,
+    :sharded_threaded => trc::ShardedThreaded,
+    :timed_queue => trc::TimedQueue,
+    :sharded_timed_queue => trc::ShardedTimedQueue,
+  }.freeze
+
+  Database.register_extension(:temporarily_release_connection) do |db|
+    unless pool_mod = trc_map[db.pool.pool_type]
+      raise(Error, "temporarily_release_connection extension not supported for connection pool type #{db.pool.pool_type}")
+    end
+
+    case db.pool.pool_type
+    when :threaded, :sharded_threaded
+      if db.opts[:connection_handling] == :disconnect
+        raise Error, "temporarily_release_connection extension not supported with connection_handling: :disconnect option"
+      end
+    end
+
+    unless db.pool.max_size == 1
+      raise Error, "temporarily_release_connection extension not supported unless :max_connections option is 1"
+    end
+
+    db.extend(trc::DatabaseMethods)
+    db.pool.extend(trc::PoolMethods)
+    db.pool.extend(pool_mod)
+  end
+
+  private_constant :TemporarilyReleaseConnection
+end

data/lib/sequel/extensions/virtual_row_method_block.rb

@@ -14,6 +14,7 @@ module Sequel
   module SQL
     class VirtualRow < BasicObject
       include(Module.new do
+        Sequel.set_temp_name(self){"Sequel::SQL:VirtualRow::_MethodBlockMethodMissing"}
         # Handle blocks passed to methods and change the behavior.
         def method_missing(m, *args, &block)
           if block

data/lib/sequel/model/associations.rb

@@ -414,6 +414,12 @@ module Sequel
           false
         end
 
+        # Hash value for the association reflection.  This is precomputed to avoid
+        # concurrency issues at runtime.
+        def hash
+          self[:_hash]
+        end
+
         # Initialize the associations cache for the current association for the given objects.
         def initialize_association_cache(objects)
           name = self[:name]
@@ -693,6 +699,9 @@ module Sequel
 
         # The predicate condition to use for the eager_loader.
         def eager_loading_predicate_condition(keys)
+          if transform = self[:eager_loading_predicate_transform]
+            keys = transform.call(keys, self)
+          end
           {predicate_key=>keys}
         end
 
@@ -759,7 +768,15 @@ module Sequel
         def placeholder_eager_loader
           cached_fetch(:placeholder_eager_loader) do
             eager_loading_dataset.placeholder_literalizer_loader do |pl, ds|
-              apply_eager_limit_strategy(ds.where(predicate_key=>pl.arg), eager_limit_strategy)
+              arg = pl.arg
+
+              if transform = self[:eager_loading_predicate_transform]
+                arg = arg.transform do |v|
+                  transform.call(v, self)
+                end
+              end
+
+              apply_eager_limit_strategy(ds.where(predicate_key=>arg), eager_limit_strategy)
             end
           end
         end
@@ -1707,6 +1724,9 @@ module Sequel
         #                  record should be populated.
         # :eager_loader_key :: A symbol for the key column to use to populate the key_hash
         #                      for the eager loader.  Can be set to nil to not populate the key_hash.
+        # :eager_loading_predicate_transform :: A callable object with which to transform the predicate key values used
+        #                                       when eager loading. Called with two arguments, the array of predicate key
+        #                                       values, and a the reflection for the association being eager loaded.
         # :extend :: A module or array of modules to extend the dataset with.
         # :filter_limit_strategy :: Determines the strategy used for enforcing limits and offsets when filtering by
         #                           limited associations.  Possible options are :window_function, :distinct_on, or
@@ -1769,6 +1789,9 @@ module Sequel
         #            Set to nil to not define a setter method for the association.
         # :subqueries_per_union :: The number of subqueries to use in each UNION query, for eager
         #                          loading limited associations using the default :union strategy.
+        # :use_placeholder_loader :: Whether to use a placeholder loader when eager loading the
+        #                            association.  Can be set to false to disable the use of a placeholder
+        #                            loader if one would be used by default.
         # :validate :: Set to false to not validate when implicitly saving any associated object.
         # === :many_to_one
         # :key :: foreign key in current model's table that references
@@ -1891,7 +1914,7 @@ module Sequel
             raise(Error, "cannot clone an association to an association of different type (association #{name} with type #{type} cloning #{opts[:clone]} with type #{cloned_assoc[:type]})")
           end
 
-          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph]
+          opts[:use_placeholder_loader] = !opts[:instance_specific] && !opts[:eager_graph] unless opts.include?(:use_placeholder_loader)
           opts[:eager_block] = opts[:block] unless opts.include?(:eager_block)
           opts[:graph_join_type] ||= :left_outer
           opts[:order_eager_graph] = true unless opts.include?(:order_eager_graph)
@@ -1914,6 +1937,8 @@ module Sequel
           # Remove :class entry if it exists and is nil, to work with cached_fetch
           opts.delete(:class) unless opts[:class]
 
+          opts[:_hash] = [self, name].hash
+
           def_association(opts)
       
           orig_opts.delete(:clone)
@@ -3591,7 +3616,7 @@ module Sequel
 
         # Prepare a hash loaders and eager options which will be used to implement the eager loading.
         def prepare_eager_load(a, reflections, eager_assoc)
-          eager_load_data = {}
+          eager_load_data = {}.compare_by_identity
 
           # Key is foreign/primary key name symbol.
           # Value is hash with keys being foreign/primary key values (generally integers)

data/lib/sequel/model/base.rb

@@ -87,7 +87,7 @@ module Sequel
       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 +184,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
@@ -398,7 +398,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
@@ -533,10 +533,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)
@@ -762,22 +780,36 @@ 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
-        singleton_class.send(:alias_method, meth, meth)
-        # :nocov:
-        singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
-        # :nocov:
+        mod.send(:alias_method, meth, meth)
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -943,7 +975,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
       
@@ -1311,7 +1346,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.
@@ -1597,7 +1632,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 +2029,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 +2278,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 +2306,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

data/lib/sequel/plugins/association_pks.rb

@@ -294,7 +294,7 @@ module Sequel
           sch = klass.db_schema
 
           if primary_key.is_a?(Array)
-            if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?
+            if (cols = sch.values_at(*klass.primary_key)).all? && (cols.map{|c| c[:type] == :integer}).all?
               db = model.db
               pks.map do |cpk|
                 cpk.map do |pk|

data/lib/sequel/plugins/column_encryption.rb

@@ -586,7 +586,7 @@ module Sequel
         end
       end
 
-      def self.apply(model, opts=OPTS)
+      def self.apply(model, opts=OPTS, &_)
         model.plugin :serialization
       end
 

data/lib/sequel/plugins/composition.rb

@@ -61,7 +61,7 @@ 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
 

data/lib/sequel/plugins/defaults_setter.rb

@@ -26,6 +26,12 @@ module Sequel
     #   Album.default_values[:a] = lambda{Date.today}
     #   Album.new.a # => Date.today
     #
+    # If the proc accepts a single argument, it is passed the instance, allowing
+    # default values to depend on instance-specific state:
+    #
+    #   Album.default_values[:a] = lambda{|album| album.b + 1}
+    #   Album.new(b: 10).a # => 11
+    #
     # By default, default values returned are not cached:
     #
     #   Album.new.a.equal?(Album.new.a) # => false
@@ -43,13 +49,13 @@ module Sequel
     #   album.values # => {}
     #   album.a
     #   album.values # => {:a => Date.today}
-    # 
+    #
     # Usage:
     #
     #   # Make all model subclass instances set defaults (called before loading subclasses)
     #   Sequel::Model.plugin :defaults_setter
     #
-    #   # Make the Album class set defaults 
+    #   # Make the Album class set defaults
     #   Album.plugin :defaults_setter
     module DefaultsSetter
       # Set the default values based on the model schema. Options:
@@ -76,7 +82,7 @@ module Sequel
         def cache_default_values?
           @cache_default_values
         end
-        
+
         # Freeze default values when freezing model class
         def freeze
           @default_values.freeze
@@ -133,7 +139,13 @@ module Sequel
         def [](k)
           if new? && !values.has_key?(k)
             v = model.default_values.fetch(k){return}
-            v = v.call if v.respond_to?(:call)
+            if v.respond_to?(:call)
+              v = if v.respond_to?(:arity) && v.arity == 1
+                v.call(self)
+              else
+                v.call
+              end
+            end
             values[k] = v if model.cache_default_values?
             v
           else

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,7 +101,17 @@ 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
@@ -179,7 +192,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/input_transformer.rb

@@ -24,7 +24,7 @@ module Sequel
     #   # Make the Album class support input transformers 
     #   Album.plugin :input_transformer
     module InputTransformer
-      def self.apply(model, *)
+      def self.apply(model, *, &_)
         model.instance_exec do
           @input_transformers = {}
           @skip_input_transformer_columns = {}

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

@@ -102,7 +102,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/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/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?