sequel 5.39.0 → 5.63.0

data/lib/sequel/plugins/require_valid_schema.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The require_valid_schema plugin makes Sequel raise or warn if attempting
+    # to set the dataset of a model class to a simple table, where the database
+    # supports schema parsing, but schema parsing does not work for the model's
+    # table.
+    #
+    # The plugin's default behavior requires that all models that select from a
+    # single identifier have a valid table schema, if the database supports
+    # schema parsing. If the schema cannot be determined for such
+    # a model, an error is raised:
+    #   
+    #   Sequel::Model.plugin :require_valid_schema
+    #
+    # If you load the plugin with an argument of :warn, Sequel will warn instead
+    # of raising for such tables:
+    #
+    #   Sequel::Model.plugin :require_valid_schema, :warn
+    #
+    # This can catch bugs where you expect models to have valid schema, but
+    # they do not. This setting only affects future attempts to set datasets
+    # in the current class and subclasses created in the future.
+    #
+    # If you load the plugin with an argument of false, it will not require valid schema.
+    # This can be used in subclasses where you do not want to require valid schema,
+    # but the plugin must be loaded before a dataset with invalid schema is set:
+    #
+    #   Sequel::Model.plugin :require_valid_schema
+    #   InvalidSchemaAllowed = Class.new(Sequel::Model)
+    #   InvalidSchemaAllowed.plugin :require_valid_schema, false
+    #   class MyModel < InvalidSchemaAllowed
+    #   end
+    module RequireValidSchema
+      # Modify the current model's dataset selection, if the model
+      # has a dataset.
+      def self.configure(model, setting=true)
+        model.instance_variable_set(:@require_valid_schema, setting)
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@require_valid_schema=>nil)
+
+        private
+
+        # If the schema cannot be determined, the model uses a simple table,
+        # require_valid_schema is set, and the database supports schema parsing, raise or
+        # warn based on the require_valid_schema setting.
+        def get_db_schema_array(reload)
+          schema_array = super
+
+          if !schema_array && simple_table && @require_valid_schema
+            message = "Not able to parse schema for model: #{inspect}, table: #{simple_table}"
+            if @require_valid_schema == :warn
+              warn message
+            else
+              raise Error, message
+            end
+          end
+
+          schema_array
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/serialization.rb

@@ -127,7 +127,7 @@ module Sequel
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
             unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.map(&:inspect).join})")
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.inspect})")
             end
           end
           serializer, deserializer = format
@@ -154,7 +154,10 @@ module Sequel
                   deserialized_values[column] = deserialize_value(column, super())
                 end
               end
-              define_method("#{column}=") do |v| 
+              alias_method(column, column)
+
+              setter = :"#{column}="
+              define_method(setter) do |v| 
                 cc = changed_columns
                 if !cc.include?(column) && (new? || get_column_value(column) != v)
                   cc << column
@@ -164,6 +167,7 @@ module Sequel
 
                 deserialized_values[column] = v
               end
+              alias_method(setter, setter)
             end
           end
         end
@@ -177,8 +181,10 @@ module Sequel
 
         # Freeze the deserialized values
         def freeze
-          deserialized_values.freeze
+          deserialized_values
           super
+          deserialized_values.freeze
+          self
         end
 
         # Serialize deserialized values before saving

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -50,8 +50,9 @@ module Sequel
         # Freeze the original deserialized values when freezing the instance.
         def freeze
           @original_deserialized_values ||= {}
-          @original_deserialized_values.freeze
           super
+          @original_deserialized_values.freeze
+          self
         end
 
         private

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -253,6 +253,14 @@ module Sequel
 
         private
 
+        # Limit tactical eager loading objects to objects that support the same association.
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          name = opts[:name]
+          objects.select!{|x| x.model.association_reflections.include?(name)}
+          objects
+        end
+
         # Don't allow use of prepared statements.
         def use_prepared_statements_for?(type)
           false

data/lib/sequel/plugins/sql_comments.rb

@@ -0,0 +1,189 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The sql_comments plugin will automatically use SQL comments on
+    # queries for the model it is loaded into.  These comments will
+    # show the related model, what type of method was called, and
+    # the method name (or association name for queries to load
+    # associations):
+    #
+    #   album = Album[1]
+    #   # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    #   # -- model:Album,method_type:class,method:[]
+    #
+    #   album.update(name: 'A')
+    #   # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    #   # -- model:Album,method_type:instance,method:update
+    #
+    #   album.artist
+    #   # SELECT * FROM artists WHERE (artists.id = 1)
+    #   # -- model:Album,method_type:association_load,association:artist
+    #
+    #   Album.eager(:artists).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM artists WHERE (artists.id IN (1))
+    #   # -- model:Album,method_type:association_eager_load,association:artist
+    #   
+    #   Album.where(id: 1).delete
+    #   # DELETE FROM albums WHERE (id = 1)
+    #   # -- model:Album,method_type:dataset,method:delete
+    #
+    # This plugin automatically supports the class, instance, and dataset
+    # methods are are supported by default in Sequel::Model.  To support
+    # custom class, instance, and dataset methods, such as those added by
+    # other plugins, you can use the appropriate <tt>sql_comments_*_methods</tt>
+    # class method:
+    #
+    #   Album.sql_comments_class_methods :first_by_name # example from finder plugin, with :mod option
+    #   Album.sql_comments_instance_methods :lazy_attribute_lookup # lazy_attributes plugin
+    #   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.
+    #
+    # Note that in order to make sure SQL comments are included, some
+    # optimizations are disabled if this plugin is loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support automatic SQL comments
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :sql_comments
+    #
+    #   # Make the Album class support automatic SQL comments
+    #   Album.plugin :sql_comments
+    module SqlComments
+      # Define a method +meth+ on the given module +mod+ that will use automatic
+      # SQL comments with the given model, method_type, and method.
+      def self.def_sql_commend_method(mod, model, method_type, meth)
+        mod.send(:define_method, meth) do |*a, &block|
+          model.db.with_comments(:model=>model, :method_type=>method_type, :method=>meth) do
+            super(*a, &block)
+          end
+        end
+        # :nocov:
+        mod.send(:ruby2_keywords, meth) if mod.respond_to?(:ruby2_keywords, true)
+        # :nocov:
+      end
+
+      def self.configure(model)
+        model.send(:reset_fast_pk_lookup_sql)
+      end
+
+      module ClassMethods
+        # Use automatic SQL comments for the given class methods.
+        def sql_comments_class_methods(*meths)
+          _sql_comments_methods(singleton_class, :class, meths)
+        end
+
+        # Use automatic SQL comments for the given instance methods.
+        def sql_comments_instance_methods(*meths)
+          _sql_comments_methods(self, :instance, meths)
+        end
+
+        # 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)
+          end
+          _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
+        end
+
+        [:[], :create, :find, :find_or_create, :with_pk, :with_pk!].each do |meth|
+          define_method(meth) do |*a, &block|
+            db.with_comments(:model=>self, :method_type=>:class, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Don't optimize the fast PK lookups, as it uses static SQL that
+        # won't support the SQL comments.
+        def reset_fast_pk_lookup_sql
+          @fast_pk_lookup_sql = @fast_instance_delete_sql = nil
+        end
+
+        # Define automatic SQL comment methods in +mod+ for each method in +meths+,
+        # with the given +method_type+.
+        def _sql_comments_methods(mod, method_type, meths)
+          meths.each do |meth|
+            SqlComments.def_sql_commend_method(mod, self, method_type, meth)
+          end
+        end
+      end
+
+      module InstanceMethods
+        [:delete, :destroy, :lock!, :refresh, :save, :save_changes, :update, :update_fields].each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:instance, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Do not use a placeholder loader for associations.
+        def _associated_object_loader(opts, dynamic_opts)
+          nil
+        end
+
+        # Use SQL comments on normal association load queries, showing they are association loads.
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          db.with_comments(:model=>model, :method_type=>:association_load, :association=>opts[:name]) do
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        Dataset::ACTION_METHODS.each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:dataset, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Add the association name as part of the eager load data, so
+        # perform_eager_load has access to it.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          res = super
+          
+          reflections.each do |r|
+            res[r[:eager_loader]][:association] = r[:name]
+          end
+
+          res
+        end
+
+        # Use SQL comments on eager load queries, showing they are eager loads.
+        def perform_eager_load(loader, eo)
+          db.with_comments(:model=>model, :method_type=>:association_eager_load, :method=>nil, :association=>eo[:association]) do
+            super
+          end
+        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)

data/lib/sequel/plugins/subclasses.rb

@@ -5,7 +5,7 @@ module Sequel
     # 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:
+    # descendants method:
     #
     #   c = Class.new(Sequel::Model)
     #   c.plugin :subclasses
@@ -16,7 +16,7 @@ module Sequel
     #   sc1.subclasses  # [ssc1]
     #   sc2.subclasses  # []
     #   ssc1.subclasses # []
-    #   c.descendents   # [sc1, ssc1, sc2]
+    #   c.descendants   # [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
@@ -35,9 +35,14 @@ module Sequel
     #   class B < Sequel::Model; end
     #   a # => [A, B]
     module Subclasses
+      NEED_SUBCLASSES = !Object.respond_to?(:subclasses) || Object.method(:subclasses).source_location
+      private_constant :NEED_SUBCLASSES
+
       # Initialize the subclasses instance variable for the model.
       def self.apply(model, &block)
-        model.instance_variable_set(:@subclasses, [])
+        # :nocov:
+        model.instance_variable_set(:@subclasses, [])  if NEED_SUBCLASSES
+        # :nocov:
         model.instance_variable_set(:@on_subclass, block)
       end
 
@@ -46,21 +51,31 @@ module Sequel
         # class created.
         attr_reader :on_subclass
 
-        # All subclasses for the current model.  Does not
-        # include the model itself.
-        attr_reader :subclasses
+        # :nocov:
+        if NEED_SUBCLASSES
+          # All subclasses for the current model.  Does not
+          # include the model itself.
+          attr_reader :subclasses
+        end
+        # :nocov:
 
         # All descendent classes of this model.
-        def descendents
-          Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendents)}.flatten
+        def descendants
+          Sequel.synchronize{subclasses.dup}.map{|x| [x] + x.send(:descendants)}.flatten
         end
 
+        # SEQUEL6: Remove
+        alias descendents descendants
+
         # Freeze all descendent classes.  This also finalizes the associations for those
         # classes before freezing.
-        def freeze_descendents
-          descendents.each(&:finalize_associations).each(&:freeze)
+        def freeze_descendants
+          descendants.each(&:finalize_associations).each(&:freeze)
         end
 
+        # SEQUEL6: Remove
+        alias freeze_descendents freeze_descendants
+
         Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
 
         private
@@ -70,7 +85,9 @@ module Sequel
         # in the subclass.
         def inherited(subclass)
           super
-          Sequel.synchronize{subclasses << subclass}
+          # :nocov:
+          Sequel.synchronize{subclasses << subclass} if NEED_SUBCLASSES
+          # :nocov:
           on_subclass.call(subclass) if on_subclass
         end
       end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -109,6 +109,13 @@ module Sequel
     # to eagerly set the associated objects, and having separate threads
     # modify the same model instance is not thread-safe.
     #
+    # Because this plugin will automatically use eager loading for
+    # performance, it can break code that defines associations that
+    # do not support eager loading, without marking that they do not
+    # support eager loading via the <tt>allow_eager: false</tt> option.
+    # Make sure to set <tt>allow_eager: false</tt> on any association
+    # used with this plugin if the association doesn't support eager loading.
+    #
     # Usage:
     #
     #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)
@@ -143,19 +150,25 @@ module Sequel
         def load_associated_objects(opts, dynamic_opts=OPTS, &block)
           dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
-          if (!associations.include?(name) || dynamic_opts[:eager_reload]) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
-            begin
-              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || OPTS)
-            rescue Sequel::UndefinedAssociation
-              # This can happen if class table inheritance is used and the association
-              # is only defined in a subclass.  This particular instance can use the
-              # association, but it can't be eagerly loaded as the parent class doesn't
-              # have access to the association, and that's the class doing the eager loading.
-              nil
-            end
+          eager_reload = dynamic_opts[:eager_reload]
+          if (!associations.include?(name) || eager_reload) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
+            retrieved_by.send(:eager_load, _filter_tactical_eager_load_objects(:eager_reload=>eager_reload, :name=>name), {name=>dynamic_opts[:eager] || OPTS}, model)
           end
           super
         end
+
+        # Filter the objects used when tactical eager loading.
+        # By default, this removes frozen objects and objects that alreayd have the association loaded
+        def _filter_tactical_eager_load_objects(opts)
+          objects = defined?(super) ? super : retrieved_with.dup
+          if opts[:eager_reload]
+            objects.reject!(&:frozen?)
+          else
+            name = opts[:name]
+            objects.reject!{|x| x.frozen? || x.associations.include?(name)}
+          end
+          objects
+        end
       end
 
       module DatasetMethods

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,