sequel 5.20.0 → 5.49.0

data/lib/sequel/plugins/skip_saving_columns.rb

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The skip_saving_columms plugin allows skipping specific columns when
+    # saving.  By default, it skips columns that the database schema
+    # indicates are generated columns:
+    #
+    #   # Assume id column, name column, and id2 generated column
+    #   album = Album[1]
+    #   album.id # => 1
+    #   album.name # => 'X'
+    #   album.id2 # => 2
+    #   album.save
+    #   # UPDATE album SET name = 'X' WHERE (id = 1)
+    #
+    # You can override which columns will be skipped:
+    #
+    #   Album.skip_saving_columns = [:name]
+    #   album.save
+    #   # UPDATE album SET id2 = 2 WHERE (id = 1)
+    #
+    # The skipping happens for all usage of Model#save and callers of it (e.g.
+    # Model.create, Model.update).  When using the plugin, the only way to get
+    # it to save a column marked for skipping is to explicitly specify it:
+    #
+    #   album.save(columns: [:name, :id2])
+    #   album.save
+    #   # UPDATE album SET name = 'X', id2 = 2 WHERE (id = 1)
+    #
+    # Usage:
+    #
+    #   # Support skipping saving columns in all Sequel::Model subclasses
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :skip_saving_columns
+    #
+    #   # Support skipping saving columns in the Album class
+    #   Album.plugin :skip_saving_columns
+    module SkipSavingColumns
+      # Setup skipping of the generated columns for a model with an existing dataset.
+      def self.configure(mod)
+        mod.instance_exec do
+          set_skip_saving_generated_columns if @dataset
+        end
+      end
+
+      module ClassMethods
+        # An array of column symbols for columns to skip when saving.
+        attr_reader :skip_saving_columns
+
+        # Over the default array of columns to skip.  Once overridden, future
+        # changes to the class's dataset and future subclasses will automatically
+        # use these overridden columns, instead of introspecting the database schema.
+        def skip_saving_columns=(v) 
+          @_skip_saving_columns_no_override = true
+          @skip_saving_columns = v.dup.freeze
+        end
+
+        Plugins.after_set_dataset(self, :set_skip_saving_generated_columns)
+        Plugins.inherited_instance_variables(self, :@skip_saving_columns=>:dup, :@_skip_saving_columns_no_override=>nil)
+
+        private
+
+        # If the skip saving columns has not been overridden, check the database
+        # schema and automatically skip any generated columns.
+        def set_skip_saving_generated_columns
+          return if @_skip_saving_columns_no_override
+          s = []
+          db_schema.each do |k, v|
+            s << k if v[:generated] 
+          end
+          @skip_saving_columns = s.freeze
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Skip the columns the model has marked to skip when inserting.
+        def _insert_values
+          _save_removed_skipped_columns(Hash[super])
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # all columns.
+        def _save_update_all_columns_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # only changed columns.
+        def _save_update_changed_colums_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Remove any columns the model has marked to skip when saving.
+        def _save_removed_skipped_columns(hash)
+          model.skip_saving_columns.each do |column|
+            hash.delete(column)
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/static_cache.rb

@@ -87,7 +87,7 @@ module Sequel
         # 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))
+          if defined?(yield) || args.length > 1 || (args.length == 1 && !args[0].is_a?(Integer))
             super
           else
             @all.first(*args)
@@ -211,18 +211,23 @@ module Sequel
         # 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
 
         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)

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

@@ -28,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_exec{set_skipped_string_stripping_columns if @dataset}
+        model.send(:set_skipped_string_stripping_columns)
       end
 
       module ClassMethods

data/lib/sequel/plugins/subclasses.rb

@@ -63,6 +63,8 @@ module Sequel
 
         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/throw_failures.rb

@@ -48,7 +48,7 @@ module Sequel
         # nil if there were any.
         def catch_hook_failures
           called = ret = nil
-          caught = catch(HookFailed) do
+          catch(HookFailed) do
             ret = yield
             called = true
           end

data/lib/sequel/plugins/timestamps.rb

@@ -19,7 +19,7 @@ module Sequel
     #
     #   # Timestamp Artist instances, forcing an overwrite of the create
     #   # timestamp, and setting the update timestamp when creating
-    #   Album.plugin :timestamps, force: true, update_on_create: true
+    #   Artist.plugin :timestamps, force: true, update_on_create: true
     module Timestamps
       # Configure the plugin by setting the available options.  Note that
       # if this method is run more than once, previous settings are ignored,

data/lib/sequel/plugins/tree.rb

@@ -45,6 +45,7 @@ module Sequel
 
         model.instance_exec do
           @parent_column = opts[:key]
+          @qualified_parent_column = Sequel.deep_qualify(table_name, opts[:key])
           @tree_order = opts[:order]
           @parent_association_name = parent
           @children_association_name = children
@@ -59,17 +60,21 @@ module Sequel
         # The column symbol or array of column symbols on which to order the tree.
         attr_accessor :tree_order
         
-        # The symbol for the column containing the value pointing to the
-        # parent of the leaf.
+        # The symbol or array of symbols for the column containing the value pointing to the
+        # parent of the node.
         attr_accessor :parent_column
 
+        # The qualified identifier or array of qualified identifiers for the column
+        # containing the value pointing to the parent of the node.
+        attr_accessor :qualified_parent_column
+
         # The association name for the parent association
         attr_reader :parent_association_name
 
         # The association name for the children association
         attr_reader :children_association_name
 
-        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@tree_order=>nil, :@parent_association_name=>nil, :@children_association_name=>nil)
+        Plugins.inherited_instance_variables(self, :@parent_column=>nil, :@qualified_parent_column=>nil, :@tree_order=>nil, :@parent_association_name=>nil, :@children_association_name=>nil)
         Plugins.def_dataset_methods(self, [:roots, :roots_dataset])
 
         # Should freeze tree order if it is an array when freezing the model class.
@@ -151,7 +156,7 @@ module Sequel
         #
         #   TreeClass.roots_dataset # => Sequel::Dataset instance
         def roots_dataset
-          ds = where(Sequel.or(Array(model.parent_column).zip([])))
+          ds = where(Sequel.or(Array(model.qualified_parent_column).zip([])))
           ds = ds.order(*model.tree_order) if model.tree_order
           ds
         end

data/lib/sequel/plugins/typecast_on_load.rb

@@ -41,7 +41,9 @@ module Sequel
         # Typecast values using #load_typecast when the values are retrieved
         # from the database.
         def call(values)
-          super.load_typecast
+          o = super.load_typecast
+          o.send(:_clear_changed_columns, :initialize)
+          o
         end
 
         # Freeze typecast on load columns when freezing model class.
@@ -63,7 +65,6 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          _changed_columns.clear
           self
         end