sequel 4.26.0 → 5.37.0

data/lib/sequel/plugins/serialization.rb

@@ -1,15 +1,17 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # Sequel's built in Serialization plugin allows you to keep serialized
+    # The serialization plugin allows you to keep serialized
     # ruby objects in the database, while giving you deserialized objects
     # when you call an accessor.
     #
     # This plugin works by keeping the serialized value in the values, and
-    # adding a @deserialized_values hash.  The reader method for serialized columns
-    # will check the @deserialized_values for the value, return it if present,
-    # or deserialized the entry in @values and return it.  The writer method will
-    # set the @deserialized_values entry.  This plugin adds a before_save hook
-    # that serializes all @deserialized_values to @values.
+    # adding a deserialized_values hash.  The reader method for serialized columns
+    # will check the deserialized_values for the value, return it if present,
+    # or deserialize the entry in values and return it.  The writer method will
+    # set the deserialized_values entry.  This plugin adds a before_validation hook
+    # that serializes all deserialized_values to values.
     #
     # You can specify the serialization format as a pair of serializer/deserializer
     # callable objects.  You can also specify the serialization format as a single
@@ -35,9 +37,7 @@ module Sequel
     #
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse,
-    #     lambda(&:reverse),
-    #     lambda(&:reverse))
+    #   Sequel::Plugins::Serialization.register_format(:reverse, :reverse.to_proc, :reverse.to_proc)
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -51,10 +51,10 @@ module Sequel
     #     serialize_attributes :reverse, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [lambda(&:reverse), lambda(&:reverse)], :password
+    #     serialize_attributes [:reverse.to_proc, :reverse.to_proc], :password
     #   end
     #   user = User.create
-    #   user.permissions = { :global => 'read-only' }
+    #   user.permissions = {global: 'read-only'}
     #   user.save
     #
     # Note that if you mutate serialized column values without reassigning them,
@@ -75,7 +75,7 @@ module Sequel
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
       def self.apply(model, *args)
-        model.instance_eval do
+        model.instance_exec do
           @deserialization_map = {}
           @serialization_map = {}
         end
@@ -91,23 +91,16 @@ module Sequel
       # models to pick this format by name.  Both serializer and deserializer
       # should be callable objects.
       def self.register_format(format, serializer, deserializer)
-        REGISTERED_FORMATS[format] = [serializer, deserializer]
+        Sequel.synchronize{REGISTERED_FORMATS[format] = [serializer, deserializer].freeze}
       end
       register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
         lambda do |v|
-          begin
-            Marshal.load(v.unpack('m')[0])
-          rescue => e
-            begin
-              # Backwards compatibility for unpacked marshal output.
-              Marshal.load(v)
-            rescue
-              raise e
-            end
-          end
+          # Handle unpacked marshalled data for backwards compat
+          v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
+          Marshal.load(v)
         end)
-      register_format(:yaml, lambda(&:to_yaml), lambda{|v| YAML.load(v)})
-      register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
+      register_format(:yaml, :to_yaml.to_proc, lambda{|s| YAML.load(s)})
+      register_format(:json, Sequel.method(:object_to_json), Sequel.method(:parse_json))
 
       module ClassMethods
         # A hash with column name symbols and callable values, with the value
@@ -118,18 +111,23 @@ module Sequel
         # called to serialize the column.
         attr_reader :serialization_map
 
-        # Module to store the serialized column accessor methods, so they can
-        # call be overridden and call super to get the serialization behavior
-        attr_accessor :serialization_module
-
         Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
+
+        # Freeze serialization metadata when freezing model class.
+        def freeze
+          @deserialization_map.freeze
+          @serialization_map.freeze
+          @serialization_module.freeze if @serialization_module
+
+          super
+        end
         
         # Create instance level reader that deserializes column values on request,
         # and instance level writer that stores new deserialized values.
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
-            unless format = REGISTERED_FORMATS[format]
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map(&:inspect).join})")
+            unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.map(&:inspect).join})")
             end
           end
           serializer, deserializer = format
@@ -137,19 +135,13 @@ module Sequel
           define_serialized_attribute_accessor(serializer, deserializer, *columns)
         end
         
-        # The columns that will be serialized.  This is only for
-        # backwards compatibility, use serialization_map in new code.
-        def serialized_columns
-          serialization_map.keys
-        end
-
         private
 
         # Add serializated attribute acessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
-          include(self.serialization_module ||= Module.new) unless serialization_module
-          serialization_module.class_eval do
+          include(@serialization_module ||= Module.new) unless @serialization_module
+          @serialization_module.class_eval do
             columns.each do |column|
               m.serialization_map[column] = serializer
               m.deserialization_map[column] = deserializer
@@ -163,8 +155,9 @@ module Sequel
                 end
               end
               define_method("#{column}=") do |v| 
-                if !changed_columns.include?(column) && (new? || get_column_value(column) != v)
-                  changed_columns << column
+                cc = changed_columns
+                if !cc.include?(column) && (new? || get_column_value(column) != v)
+                  cc << column
 
                   will_change_column(column) if respond_to?(:will_change_column)
                 end
@@ -188,14 +181,14 @@ module Sequel
           super
         end
 
-        private
-
         # Serialize deserialized values before saving
-        def _before_validation
+        def before_validation
           serialize_deserialized_values
           super
         end
         
+        private
+
         # Clear any cached deserialized values when doing a manual refresh.
         def _refresh_set_values(hash)
           @deserialized_values.clear if @deserialized_values

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # This plugin extends the serialization plugin and enables it to detect
@@ -20,7 +22,7 @@ module Sequel
     #     plugin :serialization, :json, :permissions
     #     plugin :serialization_modification_detection
     #   end
-    #   user = User.create(:permissions => {})
+    #   user = User.create(permissions: {})
     #   user.permissions[:global] = 'read-only'
     #   user.save_changes
     module SerializationModificationDetection

data/lib/sequel/plugins/sharding.rb

@@ -1,12 +1,13 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The sharding plugin augments Sequel's default model sharding support
     # in the following ways:
     #
-    # * It automatically sets model instances to be saved back to the
+    # * It automatically saves model instances back to the
     #   shard they were retreived from.
-    # * It makes model associations use the same shard as the model
-    #   object.
+    # * It makes model associations use the same shard as the model object.
     # * It adds a slightly nicer API for creating model instances on
     #   specific shards.
     # 
@@ -20,7 +21,7 @@ module Sequel
     module Sharding
       module ClassMethods
         # Create a new object on the given shard s.
-        def create_using_server(s, values={}, &block)
+        def create_using_server(s, values=OPTS, &block)
           new_using_server(s, values, &block).save
         end
 
@@ -44,7 +45,7 @@ module Sequel
         # Return a newly instantiated object that is tied to the given
         # shard s.  When the object is saved, a record will be inserted
         # on shard s.
-        def new_using_server(s, values={}, &block)
+        def new_using_server(s, values=OPTS, &block)
           new(values, &block).set_server(s)
         end
 
@@ -106,12 +107,18 @@ module Sequel
         # previous row_proc, but calls set_server on the output of that row_proc,
         # ensuring that objects retrieved by a specific shard know which shard they
         # are tied to.
-        def server(s)
-          ds = super
-          if rp = row_proc
-            ds.row_proc = proc{|r| rp.call(r).set_server(s)}
+        def row_proc
+          rp = super
+          if rp
+            case server = db.pool.send(:pick_server, opts[:server])
+            when nil, :default, :read_only
+              # nothing
+            else
+              old_rp = rp
+              rp = proc{|r| old_rp.call(r).set_server(server)}
+            end
           end
-          ds
+          rp 
         end
       end
     end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The single_table_inheritance plugin allows storing all objects
@@ -37,11 +39,11 @@ module Sequel
     #   # Using integers to store the class type, with a :model_map hash
     #   # and an sti_key of :type
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{1=>:Staff, 2=>:Manager}
+    #     model_map: {1=>:Staff, 2=>:Manager}
     #
     #   # Using non-class name strings
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager}
+    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager}
     #
     #   # By default the plugin sets the respective column value
     #   # when a new instance is created.
@@ -51,22 +53,22 @@ module Sequel
     #   # You can customize this behavior with the :key_chooser option.
     #   # This is most useful when using a non-bijective mapping.
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager},
-    #     :key_chooser=>proc{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger' }
+    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager},
+    #     key_chooser: lambda{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger'}
     #
     #   # Using custom procs, with :model_map taking column values
     #   # and yielding either a class, string, symbol, or nil, 
     #   # and :key_map taking a class object and returning the column
     #   # value to use
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>proc(&:reverse),
-    #     :key_map=>proc{|klass| klass.name.reverse}
+    #     model_map: :reverse.to_proc,
+    #     key_map: lambda{|klass| klass.name.reverse}
     #
     #   # You can use the same class for multiple values.
     #   # This is mainly useful when the sti_key column contains multiple values
     #   # which are different but do not require different code.
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'staff' => "Staff",
+    #     model_map: {'staff' => "Staff",
     #                  'manager' => "Manager",
     #                  'overpayed staff' => "Staff",
     #                  'underpayed staff' => "Staff"}
@@ -78,7 +80,7 @@ module Sequel
     module SingleTableInheritance
       # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
       def self.configure(model, key, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @sti_key_array = nil
           @sti_key = key 
           @sti_dataset = dataset
@@ -93,7 +95,7 @@ module Sequel
                 end
               end
               km.each do |k,v|
-                h[k.to_s] = [ ] unless h.key?(k.to_s)
+                h[k.to_s] = [] unless h.key?(k.to_s)
                 h[k.to_s].push( *Array(v) )
               end
               h
@@ -109,7 +111,7 @@ module Sequel
               end
             end
             sti_model_map.each do |k,v|
-              h[v.to_s] = [ ] unless h.key?(v.to_s)
+              h[v.to_s] = [] unless h.key?(v.to_s)
               h[v.to_s] << k
             end
             h
@@ -117,7 +119,8 @@ module Sequel
             lambda{|klass| klass.name.to_s}
           end
           @sti_key_chooser = opts[:key_chooser] || lambda{|inst| Array(inst.model.sti_key_map[inst.model]).last }
-          dataset.row_proc = lambda{|r| model.sti_load(r)}
+
+          @dataset = @dataset.with_row_proc(model.method(:sti_load))
         end
       end
 
@@ -149,25 +152,26 @@ module Sequel
 
         Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil)
 
-        # Copy the necessary attributes to the subclasses, and filter the
-        # subclass's dataset based on the sti_kep_map entry for the class.
-        def inherited(subclass)
+        # Freeze STI information when freezing model class.  Note that
+        # because of how STI works, you should not freeze an STI subclass
+        # until after all subclasses of it have been created.
+        def freeze
+          @sti_key_array.freeze if @sti_key_array
+          @sti_key_map.freeze if @sti_key_map.is_a?(Hash)
+          @sti_model_map.freeze if @sti_model_map.is_a?(Hash)
+
           super
-          key = Array(sti_key_map[subclass]).dup
-          sti_subclass_added(key)
-          rp = dataset.row_proc
-          subclass.set_dataset(sti_dataset.filter(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>key), :inherited=>true)
-          subclass.instance_eval do
-            dataset.row_proc = rp
-            @sti_key_array = key
-            self.simple_table = nil
-          end
         end
 
         # Return an instance of the class specified by sti_key,
         # used by the row_proc.
         def sti_load(r)
-          sti_class(sti_model_map[r[sti_key]]).call(r)
+          sti_class_from_sti_key(r[sti_key]).call(r)
+        end
+
+        # Return the sti class based on one of the keys from sti_model_map.
+        def sti_class_from_sti_key(key)
+          sti_class(sti_model_map[key])
         end
 
         # Make sure that all subclasses of the parent class correctly include 
@@ -182,10 +186,36 @@ module Sequel
 
         private
 
+        # Extend the sti dataset with the module when extending the main
+        # dataset.
+        def dataset_extend(mod, opts=OPTS)
+          @sti_dataset = @sti_dataset.with_extend(mod)
+          super
+        end
+
+        # Copy the necessary attributes to the subclasses, and filter the
+        # subclass's dataset based on the sti_kep_map entry for the class.
+        def inherited(subclass)
+          super
+          key = Array(sti_key_map[subclass]).dup
+          sti_subclass_added(key)
+          rp = dataset.row_proc
+          subclass.set_dataset(sti_subclass_dataset(key), :inherited=>true)
+          subclass.instance_exec do
+            @dataset = @dataset.with_row_proc(rp)
+            @sti_key_array = key
+            self.simple_table = nil
+          end
+        end
+
         # If calling set_dataset manually, make sure to set the dataset
         # row proc to one that handles inheritance correctly.
         def set_dataset_row_proc(ds)
-          ds.row_proc = @dataset.row_proc if @dataset
+          if @dataset
+            ds.with_row_proc(@dataset.row_proc)
+          else
+            super
+          end
         end
 
         # Return a class object.  If a class is given, return it directly.
@@ -204,13 +234,17 @@ module Sequel
             raise(Error, "Invalid class type used: #{v.inspect}")
           end
         end
+
+        # Use the given dataset for the subclass, with key being the allowed
+        # values for the sti_kind field.
+        def sti_subclass_dataset(key)
+          sti_dataset.where(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>Sequel.delay{Sequel.synchronize{key}})
+        end
       end
 
       module InstanceMethods
-        private
-
         # Set the sti_key column based on the sti_key_map.
-        def _before_validation
+        def before_validation
           if new? && model.sti_key && !self[model.sti_key]
             set_column_value("#{model.sti_key}=", model.sti_key_chooser.call(self))
           end

data/lib/sequel/plugins/singular_table_names.rb

@@ -1,3 +1,5 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
     # The singular_table_names plugin changes the default

data/lib/sequel/plugins/skip_create_refresh.rb

@@ -1,8 +1,10 @@
+# frozen-string-literal: true
+
 module Sequel
   module Plugins
-    # SkipCreateRefresh is a simple plugin that make Sequel not
+    # The skip_create_refresh plugin skips the
     # refresh after saving a new model object.  Sequel does the
-    # refresh to make sure all columns are populated, which is
+    # refresh by default to make sure all columns are populated, which is
     # necessary so that database defaults work correctly.
     #
     # This plugin is mostly for performance reasons where you
@@ -10,7 +12,7 @@ module Sequel
     # but it could also help cases where records are not
     # immediately available for selection after insertion.
     #
-    # Note that Sequel does not attempt to refresh records when
+    # Note that Sequel by default does not attempt to refresh records when
     # updating existing model objects, only when inserting new
     # model objects.
     # 

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