sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/split_values.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The split_values plugin splits the values hash retreived from the
@@ -45,17 +47,22 @@ module Sequel
         # If there isn't an entry in the values hash, but there is a noncolumn_values
         # hash, look in that hash for the value.
         def [](k)
-          super || (@noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values)
+          if  (res = super).nil?
+            @noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values
+          else
+            res
+          end
         end
 
         # Check all entries in the values hash.  If any of the keys are not columns,
         # move the entry into the noncolumn_values hash.
         def split_noncolumn_values
-          @values.keys.each do |k|
-            unless columns.include?(k)
-              (@noncolumn_values ||= {})[k] = @values.delete(k)
-            end
-          end
+          cols = (@values.keys - columns)
+          return self if cols.empty?
+
+          nc = @noncolumn_values ||= {}
+          vals = @values
+          cols.each{|k| nc[k] = vals.delete(k)}
           self
         end
       end

data/lib/sequel/plugins/static_cache.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The static_cache plugin is designed for models that are not modified at all
@@ -8,12 +10,12 @@ module Sequel
     # are frozen so they won't be modified unexpectedly, and before hooks disallow
     # saving or destroying instances.
     #
-    # You can use the :frozen=>false option to have this plugin return unfrozen
+    # You can use the frozen: false option to have this plugin return unfrozen
     # instances.  This is slower as it requires creating new objects, but it allows
     # you to make changes to the object and save them.  If you set the option to false,
     # you are responsible for updating the cache manually (the pg_static_cache_updater
     # extension can handle this automatically).  Note that it is not safe to use the
-    # :frozen=>false option if you are mutating column values directly.  If you are
+    # frozen: false option if you are mutating column values directly.  If you are
     # mutating column values, you should also override Model.call to dup each mutable
     # column value to ensure it is not shared by other instances.
     #
@@ -22,8 +24,10 @@ module Sequel
     # * Primary key lookups (e.g. Model[1])
     # * Model.all
     # * Model.each
+    # * Model.first (without block, only supporting no arguments or single integer argument)
     # * Model.count (without an argument or block)
     # * Model.map
+    # * Model.as_hash
     # * Model.to_hash
     # * Model.to_hash_groups
     #
@@ -34,9 +38,9 @@ module Sequel
     #
     #   # Cache the AlbumType class statically, but return unfrozen instances
     #   # that can be modified.
-    #   AlbumType.plugin :static_cache, :frozen=>false
+    #   AlbumType.plugin :static_cache, frozen: false
     #
-    # If you would like the speed benefits of keeping :frozen=>true but still need
+    # If you would like the speed benefits of keeping frozen: true but still need
     # to occasionally update objects, you can side-step the before_ hooks by
     # overriding the class method +static_cache_allow_modifications?+ to return true:
     #
@@ -51,14 +55,14 @@ module Sequel
     # Now if you +#dup+ a Model object (the resulting object is not frozen), you
     # will be able to update and save the duplicate.
     # Note the caveats around your responsibility to update the cache still applies.
-    #
+    # You can update the cache via `.load_cache` method.
     module StaticCache
       # Populate the static caches when loading the plugin. Options:
       # :frozen :: Whether retrieved model objects are frozen.  The default is true,
       #            for better performance as the shared frozen objects can be used
       #            directly.  If set to false, new instances are created.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @static_cache_frozen = opts.fetch(:frozen, true)
           load_cache
         end
@@ -68,13 +72,25 @@ module Sequel
         # A frozen ruby hash holding all of the model's frozen instances, keyed by frozen primary key.
         attr_reader :cache
 
-        # An array of all of the model's frozen instances, without issuing a database
-        # query.
-        def all
-          if @static_cache_frozen
-            @all.dup
+        # An array of all of the model's instances, without issuing a database
+        # query. If a block is given, yields each instance to the block.
+        def all(&block)
+          array = @static_cache_frozen ? @all.dup : to_a
+          array.each(&block) if block
+          array
+        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 block_given? || args.length > 1 || (args.length == 1 && !args[0].is_a?(Integer))
+            super
           else
-            map{|o| o}
+            @all.first(*args)
           end
         end
 
@@ -125,41 +141,46 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@static_cache_frozen=>nil)
 
         # Use the cache instead of a query to get the results.
-        def to_hash(key_column = nil, value_column = nil)
-        if key_column.nil? && value_column.nil?
-          if @static_cache_frozen
-            return Hash[cache]
-          else
-            key_column = primary_key
+        def as_hash(key_column = nil, value_column = nil, opts = OPTS)
+          if key_column.nil? && value_column.nil?
+            if @static_cache_frozen && !opts[:hash]
+              return Hash[cache]
+            else
+              key_column = primary_key
+            end
           end
-        end
 
-        h = {}
-        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)}
+          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
-              @all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              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)] = static_cache_object(r)}
           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
+            @all.each{|r| h[r[key_column]] = static_cache_object(r)}
           end
-        elsif key_column.is_a?(Array)
-          @all.each{|r| h[r.values.values_at(*key_column)] = static_cache_object(r)}
-        else
-          @all.each{|r| h[r[key_column]] = static_cache_object(r)}
+          h
         end
-        h
+
+        # 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)
-          h = {}
+        def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+          h = opts[:hash] || {}
           if value_column
             if value_column.is_a?(Array)
               if key_column.is_a?(Array)
@@ -187,28 +208,33 @@ module Sequel
           !@static_cache_frozen
         end
 
-        private
-
-        # Return the frozen object with the given pk, or nil if no such object exists
-        # in the cache, without issuing a database query.
-        def primary_key_lookup(pk)
-          static_cache_object(cache[pk])
-        end
-
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
-          a = dataset.all
+          @all = load_static_cache_rows
           h = {}
-          a.each do |o|
+          @all.each do |o|
             o.errors.freeze
             h[o.pk.freeze] = o.freeze
           end
-          @all = a.freeze
           @cache = h.freeze
         end
 
-        # If :frozen=>false is not used, just return the argument. Otherwise,
+        private
+
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        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 primary_key_lookup(pk)
+          static_cache_object(cache[pk])
+        end
+
+        # If frozen: false is not used, just return the argument. Otherwise,
         # create a new instance with the arguments values if the argument is
         # not nil.
         def static_cache_object(o)
@@ -221,15 +247,15 @@ module Sequel
       end
 
       module InstanceMethods
-        # Disallowing destroying the object unless the :frozen=>false option was used.
+        # Disallowing destroying the object unless the frozen: false option was used.
         def before_destroy
-          return false unless model.static_cache_allow_modifications?
+          cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
           super
         end
 
-        # Disallowing saving the object unless the :frozen=>false option was used.
+        # Disallowing saving the object unless the frozen: false option was used.
         def before_save
-          return false unless model.static_cache_allow_modifications?
+          cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
           super
         end
       end

data/lib/sequel/plugins/static_cache_cache.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+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.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses that use the static_cache plugin use
+    #   # the cached values in the given file
+    #   Sequel::Model.plugin :static_cache_cache, "static_cache.cache"
+    #
+    #   # Make the AlbumType model the cached values in the given file,
+    #   # should be loaded before the static_cache plugin
+    #   AlbumType.plugin :static_cache_cache, "static_cache.cache"
+    module StaticCacheCache
+      def self.configure(model, file)
+        model.instance_variable_set(:@static_cache_cache_file, file)
+        model.instance_variable_set(:@static_cache_cache, File.exist?(file) ? Marshal.load(File.read(file)) : {})
+      end
+
+      module ClassMethods
+        # Dump the in-memory cached rows to the cache file.
+        def dump_static_cache_cache
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(@static_cache_cache))}
+          nil
+        end
+
+        Plugins.inherited_instance_variables(self, :@static_cache_cache_file=>nil, :@static_cache_cache=>nil)
+
+        private
+
+        # 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]}
+            rows.map{|row| call(row)}.freeze
+          else
+            rows = dataset.all.freeze
+            raw_rows = rows.map(&:values)
+            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            rows
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/string_stripper.rb

@@ -1,9 +1,11 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # StringStripper is a plugin that strips all input strings
     # when assigning to the model's values. Example:
     #
-    #   album = Album.new(:name=>' A ')
+    #   album = Album.new(name: ' A ')
     #   album.name # => 'A'
     #
     # SQL::Blob instances and all non-strings are not modified by
@@ -12,7 +14,7 @@ module Sequel
     # other columns to skip the stripping:
     #
     #   Album.skip_string_stripping :foo
-    #   Album.new(:foo=>' A ').foo # => ' A '
+    #   Album.new(foo: ' A ').foo # => ' A '
     # 
     # Usage:
     #
@@ -26,7 +28,7 @@ module Sequel
         model.plugin(:input_transformer, :string_stripper){|v| (v.is_a?(String) && !v.is_a?(SQL::Blob)) ? v.strip : v}
       end
       def self.configure(model)
-        model.instance_eval{set_skipped_string_stripping_columns if @dataset}
+        model.send(:set_skipped_string_stripping_columns)
       end
 
       module ClassMethods

data/lib/sequel/plugins/subclasses.rb

@@ -1,9 +1,11 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # The Subclasses plugin keeps track of all subclasses of the
+    # The subclasses plugin keeps track of all subclasses of the
     # current model class.  Direct subclasses are available via the
     # subclasses method, and all descendent classes are available via the
-    # descendents method.
+    # descendents method:
     #
     #   c = Class.new(Sequel::Model)
     #   c.plugin :subclasses
@@ -16,6 +18,14 @@ module Sequel
     #   ssc1.subclasses # []
     #   c.descendents   # [sc1, ssc1, sc2]
     #
+    # You can also finalize the associations and then freeze the classes
+    # in all descendent classes.  Doing so is a recommended practice after
+    # all models have been defined in production and testing, and this makes
+    # it easier than keeping track of the classes to finalize and freeze
+    # manually:
+    #
+    #   c.freeze_descendants
+    #
     # You can provide a block when loading the plugin, and it will be called
     # with each subclass created:
     #
@@ -45,8 +55,16 @@ module Sequel
           Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendents)}.flatten
         end
 
+        # Freeze all descendent classes.  This also finalizes the associations for those
+        # classes before freezing.
+        def freeze_descendents
+          descendents.each(&:finalize_associations).each(&:freeze)
+        end
+
         Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
 
+        private
+
         # Add the subclass to this model's current subclasses,
         # and initialize a new subclasses instance variable
         # in the subclass.

data/lib/sequel/plugins/subset_conditions.rb

@@ -0,0 +1,48 @@
+# frozen-string-literal: true
+
+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.
+    #
+    # 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
+    #   end
+    #
+    #   Album.where(Album.published_conditions).sql
+    #   # SELECT * FROM albums WHERE (published IS TRUE)
+    #
+    #   Album.exclude(Album.published_conditions).sql
+    #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
+    #
+    #   Album.where(Album.published_conditions | {ready: true}).sql
+    #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
+    module SubsetConditions
+      def self.apply(model, &block)
+        model.instance_exec do
+          @dataset_module_class = Class.new(@dataset_module_class) do
+            include DatasetModuleMethods
+          end
+        end
+      end
+
+      module DatasetModuleMethods
+        # Also create a method that returns the conditions the filter uses.
+        def where(name, *args, &block)
+          super
+          cond = args
+          cond = cond.first if cond.size == 1
+          define_method(:"#{name}_conditions"){filter_expr(cond, &block)}
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/table_select.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The table_select plugin changes the default selection for a
@@ -18,7 +20,7 @@ module Sequel
       # Modify the current model's dataset selection, if the model
       # has a dataset.
       def self.configure(model)
-        model.instance_eval do
+        model.instance_exec do
           self.dataset = dataset if @dataset
         end
       end
@@ -30,7 +32,7 @@ module Sequel
         # has no explicit selection, select table.* from that table.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+          unless ds.opts[:select]
             ds = ds.select_all(ds.first_source)
           end
           ds