sequel 5.83.0 → 5.106.0

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

@@ -3,18 +3,31 @@
 module Sequel
   module Plugins
     # The subset_conditions plugin creates an additional *_conditions method
-    # for every subset created, which returns the filter conditions the subset
-    # uses.  This can be useful if you want to use the conditions for a separate
-    # filter or combine them with OR.
+    # for every `subset`, `where`, and `exclude` method call in a dataset_module
+    # block. This method returns the filter conditions, which can be useful if
+    # you want to use the conditions for a separate filter or combine them with OR.
+    # It also supports where_all and where_any dataset_module methods for
+    # combining multiple dataset method filters with AND or OR.
     #
     # Usage:
     #
     #   # Add subset_conditions in the Album class
     #   Album.plugin :subset_conditions
     #
-    #   # This will now create a published_conditions method
     #   Album.dataset_module do
-    #     subset :published, published: true
+    #     # This will now create a published_conditions method
+    #     where :published, published: true
+    #
+    #     # This will now create a not_bad_conditions method
+    #     exclude :not_bad, :bad
+    #
+    #     # This will create good_and_available and
+    #     # good_and_available_conditions methods
+    #     where_all :good_and_available, :published, :not_bad
+    #
+    #     # This will create good_or_available and
+    #     # good_or_available_conditions methods
+    #     where_any :good_or_available, :published, :not_bad
     #   end
     #
     #   Album.where(Album.published_conditions).sql
@@ -25,10 +38,17 @@ module Sequel
     #
     #   Album.where(Album.published_conditions | {ready: true}).sql
     #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
+    #
+    #   Album.good_and_available.sql
+    #   SELECT * FROM albums WHERE ((published IS TRUE) AND NOT bad)
+    #
+    #   Album.good_or_available.sql
+    #   SELECT * FROM albums WHERE ((published IS TRUE) OR NOT bad)
     module SubsetConditions
       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
@@ -42,6 +62,66 @@ module Sequel
           cond = cond.first if cond.size == 1
           define_method(:"#{name}_conditions"){filter_expr(cond, &block)}
         end
+
+        # Also create a method that returns the conditions the filter uses.
+        def exclude(name, *args, &block)
+          super
+          cond = args
+          cond = cond.first if cond.size == 1
+          define_method(:"#{name}_conditions"){Sequel.~(filter_expr(cond, &block))}
+        end
+
+        # Create a method that combines filters from already registered
+        # dataset methods, and filters for rows where all of the conditions
+        # are satisfied.
+        #
+        #   Employee.dataset_module do
+        #     where :active, active: true
+        #     where :started, Sequel::CURRENT_DATE <= :start_date
+        #     where_all(:active_and_started, :active, :started)
+        #   end
+        #
+        #   Employee.active_and_started.sql
+        #   # SELECT * FROM employees WHERE ((active IS TRUE) AND (CURRENT_DATE <= start_date))
+        def where_all(name, *args)
+          _where_any_all(:&, name, args)
+        end
+
+        # Create a method that combines filters from already registered
+        # dataset methods, and filters for rows where any of the conditions
+        # are satisfied.
+        #
+        #   Employee.dataset_module do
+        #     where :active, active: true
+        #     where :started, Sequel::CURRENT_DATE <= :start_date
+        #     where_any(:active_or_started, :active, :started)
+        #   end
+        #
+        #   Employee.active_or_started.sql
+        #   # SELECT * FROM employees WHERE ((active IS TRUE) OR (CURRENT_DATE <= start_date))
+        def where_any(name, *args)
+          _where_any_all(:|, name, args)
+        end
+
+        private
+
+        if RUBY_VERSION >= '2'
+          # Backbone of #where_any and #where_all
+          def _where_any_all(meth, name, args)
+            ds = model.dataset
+            # #bind used here because the dataset module may not yet be included in the model's dataset
+            where(name, Sequel.send(meth, *args.map{|a| self.instance_method(:"#{a}_conditions").bind(ds).call}))
+          end
+        else
+          # Cannot bind module method to arbitrary objects in Ruby 1.9.
+          # :nocov:
+          def _where_any_all(meth, name, args)
+            ds = model.dataset.clone
+            ds.extend(self)
+            where(name, Sequel.send(meth, *args.map{|a| ds.send(:"#{a}_conditions")}))
+          end
+          # :nocov:
+        end
       end
     end
   end

data/lib/sequel/plugins/subset_static_cache.rb

@@ -0,0 +1,278 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The subset_static_cache plugin is designed for model subsets that are not modified at all
+    # in production use cases, or at least where modifications to them would usually
+    # coincide with an application restart.  When caching a model subset, it 
+    # retrieves all rows in the database and statically caches a ruby array and hash
+    # keyed on primary key containing all of the model instances.  All of these cached
+    # instances are frozen so they won't be modified unexpectedly.
+    #
+    # With the following code:
+    #
+    #   class StatusType < Sequel::Model
+    #     dataset_module do
+    #       where :available, hidden: false
+    #     end
+    #     cache_subset :available
+    #   end
+    #   
+    # The following methods will use the cache and not issue a database query:
+    #
+    # * StatusType.available.with_pk
+    # * StatusType.available.all
+    # * StatusType.available.each
+    # * StatusType.available.first (without block, only supporting no arguments or single integer argument)
+    # * StatusType.available.count (without an argument or block)
+    # * StatusType.available.map
+    # * StatusType.available.as_hash
+    # * StatusType.available.to_hash
+    # * StatusType.available.to_hash_groups
+    #
+    # The cache is not used if you chain methods before or after calling the cached
+    # method, as doing so would not be safe:
+    #
+    #   StatusType.where{number > 1}.available.all 
+    #   StatusType.available.where{number > 1}.all
+    #
+    # The cache is also not used if you change the class's dataset after caching
+    # the subset, or in subclasses of the model.
+    #
+    # You should not modify any row that is statically cached when using this plugin,
+    # as otherwise you will get different results for cached and uncached method
+    # calls.
+    module SubsetStaticCache
+      def self.configure(model)
+        model.class_exec do
+          @subset_static_caches ||= ({}.compare_by_identity)
+        end
+      end
+
+      module ClassMethods
+        # Cache the given subset statically, so that calling the subset method on
+        # the model will return a dataset that will return cached results instead
+        # of issuing database queries (assuming the cache has the necessary
+        # information).
+        #
+        # The model must already respond to the given method before cache_subset
+        # is called.
+        def cache_subset(meth)
+          ds = send(meth).with_extend(CachedDatasetMethods)
+          cache = ds.instance_variable_get(:@cache)
+
+          rows, hash = subset_static_cache_rows(ds, meth)
+          cache[:subset_static_cache_all] = rows
+          cache[:subset_static_cache_map] = hash
+
+          caches = @subset_static_caches
+          caches[meth] = ds
+          model = self
+          subset_static_cache_module.send(:define_method, meth) do
+            if (model == self) && (cached_dataset = caches[meth])
+              cached_dataset
+            else
+              super()
+            end
+          end
+          nil
+        end
+
+        Plugins.after_set_dataset(self, :clear_subset_static_caches)
+        Plugins.inherited_instance_variables(self, :@subset_static_caches=>proc{{}.compare_by_identity})
+
+        private
+
+        # Clear the subset_static_caches.  This is used if the model dataset
+        # changes, to prevent cached values from being used.
+        def clear_subset_static_caches
+          @subset_static_caches.clear
+        end
+
+        # A module for the subset static cache methods, so that you can define
+        # a singleton method in the class with the same name, and call super
+        # to get default behavior.
+        def subset_static_cache_module
+          return @subset_static_cache_module if @subset_static_cache_module
+
+          # Ensure dataset_methods module is defined and class is extended with
+          # it before calling creating this module.
+          dataset_methods_module
+
+          mod_name = "#{name}::@subset_static_cache_module"
+          Sequel.synchronize{@subset_static_cache_module ||= Sequel.set_temp_name(Module.new){mod_name}}
+          extend(@subset_static_cache_module)
+          @subset_static_cache_module
+        end
+         
+        # Return the frozen array and hash used for caching the subset
+        # of the given dataset.
+        def subset_static_cache_rows(ds, meth)
+          all = load_subset_static_cache_rows(ds, meth)
+          h = {}
+          all.each do |o|
+            o.errors.freeze
+            h[o.pk.freeze] = o.freeze
+          end
+          [all, h.freeze]
+        end
+
+        # Return a frozen array for all rows in the dataset.
+        def load_subset_static_cache_rows(ds, meth)
+          ret = super if defined?(super)
+          ret || ds.all.freeze
+        end
+      end
+
+      module CachedDatasetMethods
+        # An array of all of the dataset's instances, without issuing a database
+        # query. If a block is given, yields each instance to the block.
+        def all(&block)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          array = all.dup
+          array.each(&block) if block
+          array
+        end
+
+        # Get the number of records in the cache, without issuing a database query,
+        # if no arguments or block are provided.
+        def count(*a, &block)
+          if a.empty? && !block && (all = @cache[:subset_static_cache_all])
+            all.size
+          else
+            super
+          end
+        end
+
+        # If a block is given, multiple arguments are given, or a single
+        # non-Integer argument is given, performs the default behavior of
+        # issuing a database query.  Otherwise, uses the cached values
+        # to return either the first cached instance (no arguments) or an
+        # array containing the number of instances specified (single integer
+        # argument).
+        def first(*args)
+          if !defined?(yield) && args.length <= 1 && (args.length == 0 || args[0].is_a?(Integer)) && (all = @cache[:subset_static_cache_all])
+            all.first(*args)
+          else
+            super
+          end
+        end
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def with_pk(pk)
+          if cache = @cache[:subset_static_cache_map]
+            cache[pk]
+          else
+            super
+          end
+        end
+
+        # Yield each of the dataset's frozen instances to the block, without issuing a database
+        # query.
+        def each(&block)
+          return super unless all = @cache[:subset_static_cache_all]
+          all.each(&block)
+        end
+
+        # Use the cache instead of a query to get the results.
+        def map(column=nil, &block)
+          return super unless all = @cache[:subset_static_cache_all]
+          if column
+            raise(Error, "Cannot provide both column and block to map") if block
+            if column.is_a?(Array)
+              all.map{|r| r.values.values_at(*column)}
+            else
+              all.map{|r| r[column]}
+            end
+          else
+            all.map(&block)
+          end
+        end
+
+        # Use the cache instead of a query to get the results if possible
+        def as_hash(key_column = nil, value_column = nil, opts = OPTS)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          if key_column.nil? && value_column.nil?
+            if opts[:hash]
+              key_column = model.primary_key
+            else
+              return Hash[@cache[:subset_static_cache_map]]
+            end
+          end
+
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+              else
+                all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
+              else
+                all.each{|r| h[r[key_column]] = r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            all.each{|r| h[r.values.values_at(*key_column)] = r}
+          else
+            all.each{|r| h[r[key_column]] = r}
+          end
+          h
+        end
+
+        # Use the cache instead of a query to get the results.
+        def as_set(column)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          set = Set.new
+
+          if column.is_a?(Array)
+            all.each{|r| set.add(r.values.values_at(*column))}
+          else
+            all.each{|r| set.add(r[column])}
+          end
+
+          set
+        end
+
+        # Alias of as_hash for backwards compatibility.
+        def to_hash(*a)
+          as_hash(*a)
+        end
+
+        # Use the cache instead of a query to get the results
+        def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+          return super unless all = @cache[:subset_static_cache_all]
+
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r.values.values_at(*value_column)}
+              else
+                all.each{|r| (h[r[key_column]] ||= []) << r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r[value_column]}
+              else
+                all.each{|r| (h[r[key_column]] ||= []) << r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            all.each{|r| (h[r.values.values_at(*key_column)] ||= []) << r}
+          else
+            all.each{|r| (h[r[key_column]] ||= []) << r}
+          end
+          h
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/table_select.rb

@@ -9,6 +9,13 @@ module Sequel
     # in the result sets (and possibly overwrite columns in the
     # current model with the same name).
     #
+    # Note that by default on databases that supporting RETURNING,
+    # using this plugin will cause instance creations
+    # to use two queries (insert and refresh) instead of a single
+    # query using RETURNING.  You can use the insert_returning_select
+    # plugin to automatically use RETURNING for instance creations
+    # for models using this plugin.
+    #
     # Usage:
     #
     #   # Make all model subclasses select table.*

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

@@ -198,7 +198,8 @@ module Sequel
     #
     # Since this plugin is based on coverage information, if you do
     # not have tests that cover all usage of associations in your
-    # application, you can end up with coverage that shows the
+    # application, or you are mocking the related association methods
+    # and not calling them, you can end up with coverage that shows the
     # association is not used, when it is used in code that is not
     # covered.  The output of plugin can still be useful in such cases,
     # as long as you are manually checking it.  However, you should
@@ -208,6 +209,8 @@ module Sequel
     # option for any association that you know is used. If an
     # association uses the :is_used association option, this plugin
     # will not modify it if the :modify_associations option is used.
+    # It will also not report the association as unused if the :is_used
+    # association option is present.
     #
     # This plugin does not handle anonymous classes. Any unused
     # associations defined in anonymous classes will not be
@@ -347,6 +350,8 @@ module Sequel
           coverage_data = options[:coverage_data] || Sequel.parse_json(File.binread(@unused_associations_coverage_file))
 
           unused_associations_data = {}
+          to_many_modification_methods = [:adder, :remover, :clearer]
+          modification_methods = [:setter, :adder, :remover, :clearer]
 
           ([self] + descendants).each do |sc|
             next unless cov_data = coverage_data[sc.name]
@@ -360,6 +365,9 @@ module Sequel
               # looks in the class's overridable_methods_module
               next if ref[:methods_module]
 
+              # Do not report associations if they are explicitly marked as used.
+              next if ref[:is_used]
+
               info = {}
               if reflection_data.include?(assoc.to_s)
                 info[:used] = [:reflection]
@@ -383,8 +391,8 @@ module Sequel
               if !info[:used]
                 (unused_associations_data[sc.name] ||= {})[assoc.to_s] = 'unused'
               elsif unused = info[:unused]
-                if unused.include?(:setter) || [:adder, :remover, :clearer].all?{|k| unused.include?(k)}
-                  [:setter, :adder, :remover, :clearer].each do |k|
+                if unused.include?(:setter) || to_many_modification_methods.all?{|k| unused.include?(k)}
+                  modification_methods.each do |k|
                     unused.delete(k)
                   end
                   unused << :read_only

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_class_methods.rb

@@ -208,7 +208,7 @@ module Sequel
               next if an && Array(v).all?(&:nil?)
               next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
-              block.call(o,a,v)
+              yield(o, a, v)
             end
           else
             block

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