sequel 5.39.0 → 5.72.0

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

@@ -64,6 +64,9 @@ module Sequel
       def self.configure(model, opts=OPTS)
         model.instance_exec do
           @static_cache_frozen = opts.fetch(:frozen, true)
+          if @static_cache_frozen && defined?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods) && is_a?(::Sequel::Plugins::ForbidLazyLoad::ClassMethods)
+            extend ForbidLazyLoadClassMethods
+          end
           load_cache
         end
       end
@@ -87,7 +90,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)
@@ -246,6 +249,41 @@ module Sequel
         end
       end
 
+      module ForbidLazyLoadClassMethods
+        # Do not forbid lazy loading for single object retrieval.
+        def cache_get_pk(pk)
+          primary_key_lookup(pk)
+        end
+
+        # Use static cache to return first arguments.
+        def first(*args)
+          if !defined?(yield) && args.empty?
+            if o = @all.first
+              _static_cache_frozen_copy(o)
+            end
+          else
+            super
+          end
+        end
+
+        private
+
+        # Return a frozen copy of the object that does not have lazy loading
+        # forbidden.
+        def _static_cache_frozen_copy(o)
+          o = call(Hash[o.values])
+          o.errors.freeze
+          o.freeze
+        end
+
+        # Do not forbid lazy loading for single object retrieval.
+        def primary_key_lookup(pk)
+          if o = cache[pk]
+            _static_cache_frozen_copy(o)
+          end
+        end
+      end
+
       module InstanceMethods
         # Disallowing destroying the object unless the frozen: false option was used.
         def before_destroy

data/lib/sequel/plugins/static_cache_cache.rb

@@ -26,7 +26,11 @@ module Sequel
       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))}
+          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))}
           nil
         end
 

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,