sequel 5.87.0 → 5.90.0

data/lib/sequel/model/associations.rb

@@ -693,6 +693,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 +762,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 +1718,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 +1783,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 +1908,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)

data/lib/sequel/model/base.rb

@@ -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
@@ -762,22 +762,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 +957,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
       
@@ -1597,7 +1614,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

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

data/lib/sequel/plugins/nested_attributes.rb

@@ -129,7 +129,7 @@ module Sequel
         #
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
-          include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
+          include(@nested_attributes_module ||= Sequel.set_temp_name(Module.new){"#{name}::@nested_attributes_module"}) unless @nested_attributes_module
           opts = associations.last.is_a?(Hash) ? associations.pop : OPTS
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|

data/lib/sequel/plugins/pg_eager_any_typed_array.rb

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The pg_eager_any_typed_array plugin automatically converts
+    # the predicate expressions used for eager loading from:
+    #
+    #   table.column IN (value_list)
+    #
+    # to:
+    #
+    #   table.column = ANY(array_expr::type[])
+    #
+    # This makes it easier to use the pg_auto_parameterize_in_array
+    # extension with the :treat_string_list_as_text_array option,
+    # when using foreign keys with non-text database types that are represented
+    # by Ruby strings, such as enum and uuid types.
+    #
+    # Most association types that ship with Sequel have their predicate
+    # expressions converted by this plugin.  Here are the exceptions:
+    #
+    # * associations using composite predicate keys
+    # * many_to_pg_array associations
+    # * many_to_many/one_through_one associations using :join_table_db option
+    # * many_through_many/one_through_many associations using
+    #   :separate_table_per_query option
+    #
+    # To avoid predicate conversion for particular associations, set the
+    # :eager_loading_predicate_transform association option to nil/false.
+    #
+    # This plugin loads the pg_array extension into the model's Database.
+    module PgEagerAnyTypedArray
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
+      module ClassMethods
+        TRANSFORM = proc do |values, ref|
+          type = ref.send(:cached_fetch, :_pg_eager_any_typed_array_type) do
+            key = ref.predicate_key
+            next if key.is_a?(Array)
+
+            while key.is_a?(SQL::QualifiedIdentifier)
+              key = key.column
+            end
+
+            # :nocov:
+            # many_to_pg_array association type does not need changes, as it
+            # already converts the values to a typed postgres array, it does
+            # not call the code that uses :eager_loading_predicate_transform.
+            #
+            # No association type that ships with Sequel can reach this code
+            # unless it is one of these types, but external association types
+            # could potentially reach it.
+            sch = case ref[:type]
+            # :nocov:
+            when :many_to_one, :one_to_one, :one_to_many, :pg_array_to_many
+              ref.associated_class.db_schema
+            when :many_to_many, :one_through_one
+              # Not compatible with the :join_table_db option, but that option
+              # does not call into this code.
+              Hash[ref.associated_class.db.schema(ref.join_table_source)]
+            when :many_through_many, :one_through_many
+              # Not compatible with the :separate_query_per_table option, but
+              # that option does not call into this code.
+              Hash[ref.associated_class.db.schema(ref[:through][0][:table])]
+            end
+
+            if sch && (sch = sch[key])
+              sch[:db_type]
+            end
+          end
+
+          if type
+            Sequel.function(:ANY, Sequel.pg_array(values, type))
+          else
+            values
+          end
+        end
+
+        # Set the :eager_loading_predicate_transform option if not already set
+        def associate(type, name, opts = OPTS, &block)
+          res = super
+
+          unless res.has_key?(:eager_loading_predicate_transform)
+            res[:eager_loading_predicate_transform] = TRANSFORM
+          end
+
+          res
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/rcte_tree.rb

@@ -81,7 +81,7 @@ module Sequel
 
         opts = opts.dup
         opts[:class] = model
-        opts[:methods_module] = Module.new
+        opts[:methods_module] = Sequel.set_temp_name(Module.new){"#{model.name}::_rcte_tree[:methods_module]"}
         opts[:union_all] = opts[:union_all].nil? ? true : opts[:union_all]
         model.send(:include, opts[:methods_module])
         

data/lib/sequel/plugins/serialization.rb

@@ -37,7 +37,8 @@ module Sequel
     #
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse, :reverse.to_proc, :reverse.to_proc)
+    #   require 'base64'
+    #   Sequel::Plugins::Serialization.register_format(:base64, Base64.method(:encode64), Base64.method(:decode64))
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -48,10 +49,10 @@ module Sequel
     #     serialize_attributes :marshal, :permissions
     #
     #     # Use custom registered serialization format just like built-in format
-    #     serialize_attributes :reverse, :password
+    #     serialize_attributes :base64, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [:reverse.to_proc, :reverse.to_proc], :password
+    #     serialize_attributes [ Base64.method(:encode64), Base64.method(:decode64)], :password
     #   end
     #   user = User.create
     #   user.permissions = {global: 'read-only'}
@@ -123,7 +124,12 @@ module Sequel
         end
         
         # Create instance level reader that deserializes column values on request,
-        # and instance level writer that stores new deserialized values.
+        # and instance level writer that stores new deserialized values. If +format+
+        # is a symbol, it should correspond to a previously-registered format using +register_format+.
+        # Otherwise, +format+ is expected to be a 2-element array of callables,
+        # with the first element being the serializer, used to convert the value used by the application
+        # to the value that will be stored in the database, and the second element being the deserializer,
+        # used to convert the value stored the database to the value used by the application.
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
             unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
@@ -140,7 +146,7 @@ module Sequel
         # Add serializated attribute acessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
-          include(@serialization_module ||= Module.new) unless @serialization_module
+          include(@serialization_module ||= Sequel.set_temp_name(Module.new){"#{name}::@serialization_module"}) unless @serialization_module
           @serialization_module.class_eval do
             columns.each do |column|
               m.serialization_map[column] = serializer

data/lib/sequel/plugins/sql_comments.rb

@@ -40,7 +40,8 @@ module Sequel
     #   Album.sql_comments_dataset_methods :to_csv # csv_serializer plugin
     #
     # In order for the sql_comments plugin to work, the sql_comments
-    # Database extension must be loaded into the model's database.
+    # Database extension must be loaded into the model's database, so
+    # loading the plugin does this automatically.
     #
     # Note that in order to make sure SQL comments are included, some
     # optimizations are disabled if this plugin is loaded.
@@ -67,6 +68,10 @@ module Sequel
         # :nocov:
       end
 
+      def self.apply(model)
+        model.db.extension(:sql_comments)
+      end
+
       def self.configure(model)
         model.send(:reset_fast_pk_lookup_sql)
       end
@@ -85,7 +90,7 @@ module Sequel
         # Use automatic SQL comments for the given dataset methods.
         def sql_comments_dataset_methods(*meths)
           unless @_sql_comments_dataset_module
-            dataset_module(@_sql_comments_dataset_module = Module.new)
+            dataset_module(@_sql_comments_dataset_module = Sequel.set_temp_name(Module.new){"#{name}::@_sql_comments_dataset_module"})
           end
           _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
         end

data/lib/sequel/plugins/static_cache_cache.rb

@@ -2,11 +2,11 @@
 
 module Sequel
   module Plugins
-    # The static_cache_cache plugin allows for caching the row content for subclasses
-    # that use the static cache plugin (or just the current class).  Using this plugin
-    # can avoid the need to query the database every time loading the plugin into a
-    # model, which can save time when you have a lot of models using the static_cache
-    # plugin.
+    # The static_cache_cache plugin allows for caching the row content for the current
+    # class and subclasses that use the static_cache or subset_static_cache plugins.
+    # Using this plugin can avoid the need to query the database every time loading
+    # the static_cache plugin into a model (static_cache plugin) or using the
+    # cache_subset method (subset_static_cache plugin).
     #
     # Usage:
     #
@@ -26,11 +26,7 @@ module Sequel
       module ClassMethods
         # Dump the in-memory cached rows to the cache file.
         def dump_static_cache_cache
-          static_cache_cache = {}
-          @static_cache_cache.sort.each do |k, v|
-            static_cache_cache[k] = v
-          end
-          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(static_cache_cache))}
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(sort_static_cache_hash(@static_cache_cache)))}
           nil
         end
 
@@ -38,16 +34,57 @@ module Sequel
 
         private
 
+        # Sort the given static cache hash in a deterministic way, so that 
+        # the same static cache values will result in the same marshal file.
+        def sort_static_cache_hash(cache)
+          cache = cache.sort do |a, b|
+            a, = a
+            b, = b
+            if a.is_a?(Array)
+              if b.is_a?(Array)
+                a_name, a_meth = a
+                b_name, b_meth = b
+                x = a_name <=> b_name
+                if x.zero?
+                  x = a_meth <=> b_meth
+                end
+                x
+              else
+                1
+              end
+            elsif b.is_a?(Array)
+              -1
+            else
+              a <=> b
+            end
+          end
+          Hash[cache]
+        end
+
         # Load the rows for the model from the cache if available.
         # If not available, load the rows from the database, and
         # then update the cache with the raw rows.
         def load_static_cache_rows
-          if rows = Sequel.synchronize{@static_cache_cache[name]}
+          _load_static_cache_rows(dataset, name)
+        end
+
+        # Load the rows for the subset from the cache if available.
+        # If not available, load the rows from the database, and
+        # then update the cache with the raw rows.
+        def load_subset_static_cache_rows(ds, meth)
+          _load_static_cache_rows(ds, [name, meth].freeze)
+        end
+
+        # Check the cache first for the key, and return rows without a database
+        # query if present.  Otherwise, get all records in the provided dataset,
+        # and update the cache with them.
+        def _load_static_cache_rows(ds, key)
+          if rows = Sequel.synchronize{@static_cache_cache[key]}
             rows.map{|row| call(row)}.freeze
           else
-            rows = dataset.all.freeze
+            rows = ds.all.freeze
             raw_rows = rows.map(&:values)
-            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            Sequel.synchronize{@static_cache_cache[key] = raw_rows}
             rows
           end
         end

data/lib/sequel/plugins/subset_conditions.rb

@@ -48,6 +48,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(SubsetConditions)"}
             include DatasetModuleMethods
           end
         end