sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/column_select.rb

@@ -28,7 +28,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
@@ -41,15 +41,17 @@ module Sequel
         # qualifying them with table's name.
         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]
             if db.supports_schema_parsing?
-              cols = check_non_connection_error{db.schema(ds)}
+              cols = check_non_connection_error(false){db.schema(ds)}
               if cols
                 cols = cols.map{|c, _| c}
               end
             end
-            cols ||= check_non_connection_error{ds.columns}
-            ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+
+            if cols ||= check_non_connection_error(false){ds.columns}
+              ds = ds.select(*cols.map{|c| Sequel.qualify(ds.first_source, Sequel.identifier(c))})
+            end
           end
           ds
         end

data/lib/sequel/plugins/columns_updated.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The columns_updated plugin stores the columns hash used in the
+    # UPDATE query when saving the instance, and makes it available
+    # in the after_update and after_save hooks via the +columns_updated+
+    # accessor.  The data is cleared before returning from +save+.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses store the columns hash used for updating
+    #   Sequel::Model.plugin :columns_updated
+    #
+    #   # Make the Album class store the columns hash used for updating
+    #   Album.plugin :columns_updated
+    module ColumnsUpdated
+      module InstanceMethods
+        private
+
+        # The hash used for updating records.  This should only be called
+        # in the after_update and after_save hooks.
+        attr_reader :columns_updated
+
+        # Store the hash used for updating the record, so it can be accessed
+        # in the after_hooks.
+        def _update_columns(columns_updated)
+          @columns_updated = columns_updated
+          super
+        end
+
+        # Unset the updated columns hash before returning from save.
+        def _save(opts)
+          super
+        ensure
+          @columns_updated = nil
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/composition.rb

@@ -12,7 +12,7 @@ module Sequel
     # This can be handled with:
     #
     #   Album.plugin :composition
-    #   Album.composition :date, :mapping=>[:year, :month, :day]
+    #   Album.composition :date, mapping: [:year, :month, :day]
     #
     # With the :mapping option, you can provide a :class option
     # that gives the class to use, but if that is not provided, it
@@ -32,9 +32,10 @@ module Sequel
     #
     # The :mapping option is just a shortcut that works in particular
     # cases.  To handle any case, you can define a custom :composer
-    # and :decomposer procs.  The :composer proc will be instance_evaled
-    # the first time the getter is called, and the :decomposer proc
-    # will be instance_evaled before saving.  The above example could
+    # and :decomposer procs.  The :composer and :decomposer procs will
+    # be used to define instance methods.  The :composer will be called
+    # the first time the getter is called, and the :decomposer 
+    # will be called before saving.  The above example could
     # also be implemented as:
     #
     #   Album.composition :date,
@@ -58,7 +59,10 @@ module Sequel
     module Composition
       # Define the necessary class instance variables.
       def self.apply(model)
-        model.instance_eval{@compositions = {}}
+        model.instance_exec do
+          @compositions = {}
+          include(@composition_module ||= Module.new)
+        end
       end
 
       module ClassMethods
@@ -66,18 +70,14 @@ module Sequel
         # hash values.
         attr_reader :compositions
         
-        # A module included in the class holding the composition
-        # getter and setter methods.
-        attr_reader :composition_module
-        
         # Define a composition for this model, with name being the name of the composition.
         # You must provide either a :mapping option or both the :composer and :decomposer options. 
         #
         # Options:
         # :class :: if using the :mapping option, the class to use, as a Class, String or Symbol.
-        # :composer :: A proc that is instance evaled when the composition getter method is called
+        # :composer :: A proc used to define the method that the composition getter method will call 
         #              to create the composition.
-        # :decomposer :: A proc that is instance evaled before saving the model object,
+        # :decomposer :: A proc used to define the method called before saving the model object,
         #                if the composition object exists, which sets the columns in the model object
         #                based on the value of the composition object.
         # :mapping :: An array where each element is either a symbol or an array of two symbols.
@@ -86,12 +86,12 @@ module Sequel
         #             represents the getter method in the composition object. Example:
         #                 # Uses columns year, month, and day in the current model
         #                 # Uses year, month, and day methods in the composition object
-        #                 {:mapping=>[:year, :month, :day]}
+        #                 {mapping: [:year, :month, :day]}
         #                 # Uses columns year, month, and day in the current model
         #                 # Uses y, m, and d methods in the composition object where
         #                 # for example y in the composition object represents year
         #                 # in the model object.
-        #                 {:mapping=>[[:year, :y], [:month, :m], [:day, :d]]}
+        #                 {mapping: [[:year, :y], [:month, :m], [:day, :d]]}
         def composition(name, opts=OPTS)
           opts = opts.dup
           compositions[name] = opts
@@ -115,9 +115,9 @@ module Sequel
               setters = setter_meths.zip(cov_methods)
               opts[:decomposer] = proc do
                 if (o = compositions[name]).nil?
-                  setter_meths.each{|sm| get_column_value(sm, nil)}
+                  setter_meths.each{|sm| set_column_value(sm, nil)}
                 else
-                  setters.each{|sm, cm| get_column_value(sm, o.send(cm))}
+                  setters.each{|sm, cm| set_column_value(sm, o.public_send(cm))}
                 end
               end
             end
@@ -130,24 +130,37 @@ module Sequel
         
         # Define getter and setter methods for the composition object.
         def define_composition_accessor(name, opts=OPTS)
-          include(@composition_module ||= Module.new) unless composition_module
-          composer = opts[:composer]
-          composition_module.class_eval do
+          composer_meth = opts[:composer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_composer", 0, &opts[:composer])
+          opts[:decomposer_method] = Plugins.def_sequel_method(@composition_module, "#{name}_decomposer", 0, &opts[:decomposer])
+          @composition_module.class_eval do
             define_method(name) do 
               if compositions.has_key?(name)
                 compositions[name]
               elsif frozen?
-                instance_eval(&composer)
+                # composer_meth is private
+                send(composer_meth)
               else
-                compositions[name] = instance_eval(&composer)
+                compositions[name] = send(composer_meth)
               end
             end
-            define_method("#{name}=") do |v|
+            alias_method(name, name)
+
+            meth = :"#{name}="
+            define_method(meth) do |v|
               modified!
               compositions[name] = v
             end
+            alias_method(meth, meth)
           end
         end
+
+        # Freeze composition information when freezing model class.
+        def freeze
+          compositions.freeze.each_value(&:freeze)
+          @composition_module.freeze
+
+          super
+        end
       end
 
       module InstanceMethods
@@ -158,19 +171,22 @@ module Sequel
 
         # Freeze compositions hash when freezing model instance.
         def freeze
-          compositions.freeze
+          compositions
           super
+          compositions.freeze
+          self
         end
 
-        private
-
         # For each composition, set the columns in the model class based
         # on the composition object.
-        def _before_validation
-          @compositions.keys.each{|n| instance_eval(&model.compositions[n][:decomposer])} if @compositions
+        def before_validation
+          # decomposer_method is private
+          @compositions.keys.each{|n| send(model.compositions[n][:decomposer_method])} if @compositions
           super
         end
         
+        private
+
         # Clear the cached compositions when manually refreshing.
         def _refresh_set_values(hash)
           @compositions.clear if @compositions

data/lib/sequel/plugins/concurrent_eager_loading.rb

@@ -0,0 +1,174 @@
+# frozen-string-literal: true
+
+module Sequel
+  extension 'async_thread_pool'
+
+  module Plugins
+    # The concurrent_eager_loading plugin allows for eager loading multiple associations
+    # concurrently in separate threads.  You must load the async_thread_pool Database
+    # extension into the Database object the model class uses in order for this plugin
+    # to work.
+    # 
+    # By default in Sequel, eager loading happens in a serial manner.  If you have code
+    # such as:
+    #
+    #   Album.eager(:artist, :genre, :tracks)
+    #
+    # Sequel will load the albums, then the artists for the albums, then
+    # the genres for the albums, then the tracks for the albums.
+    #
+    # With the concurrent_eager_loading plugin, you can use the +eager_load_concurrently+
+    # method to allow for concurrent eager loading:
+    #
+    #   Album.eager_load_concurrently.eager(:artist, :genre, :tracks)
+    #
+    # This will load the albums, first, since it needs to load the albums to know
+    # which artists, genres, and tracks to eagerly load. However, it will load the
+    # artists, genres, and tracks for the albums concurrently in separate threads.
+    # This can significantly improve performance, especially if there is significant
+    # latency between the application and the database. Note that using separate threads
+    # is only used in the case where there are multiple associations to eagerly load.
+    # With only a single association to eagerly load, there is no reason to use a
+    # separate thread, since it would not improve performance.
+    #
+    # If you want to make concurrent eager loading the default, you can load the
+    # plugin with the +:always+ option. In this case, all eager loads will be
+    # concurrent.  If you want to force a non-concurrent eager load, you can use
+    # +eager_load_serially+:
+    #
+    #   Album.eager_load_serially.eager(:artist, :genre, :tracks)
+    #
+    # Note that making concurrent eager loading the default is probably a bad idea
+    # if you are eager loading inside transactions and want the eager load to
+    # reflect changes made inside the transaction, unless you plan to use
+    # +eager_load_serially+ for such cases.  See the async_thread_pool
+    # Database extension documentation for more general caveats regarding its use.
+    #
+    # The default eager loaders for all of the association types that ship with Sequel
+    # support safe concurrent eager loading.  However, if you are specifying a custom
+    # +:eager_loader+ for an association, it may not work safely unless it it modified to
+    # support concurrent eager loading.  Taking this example from the
+    # {Advanced Associations guide}[rdoc-ref:doc/advanced_associations.rdoc]
+    #
+    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
+    #     id_map = eo_opts[:id_map]
+    #     Artist.where(:id=>id_map.keys).all do |artist|
+    #       if albums = id_map[artist.id]
+    #         albums.each do |album|
+    #           album.associations[:artist] = artist
+    #         end
+    #       end
+    #     end
+    #   end)
+    #
+    # This would not support concurrent eager loading safely.  To support safe
+    # concurrent eager loading, you need to make sure you are not modifying
+    # the associations for objects concurrently by separate threads.  This is
+    # implemented using a mutex, which you can access via <tt>eo_opts[:mutex]</tt>.
+    # To keep things simple, you can use +Sequel.synchronize_with+ to only
+    # use this mutex if it is available.  You want to use the mutex around the
+    # code that initializes the associations (usually to +nil+ or <tt>[]</tt>),
+    # and also around the code that sets the associatied objects appropriately
+    # after they have been retreived.  You do not want to use the mutex around
+    # the code that loads the objects, since that will prevent concurrent loading.
+    # So after the changes, the custom eager loader would look like this:
+    #
+    #   Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+    #     Sequel.synchronize_with(eo[:mutex]) do
+    #       eo_opts[:rows].each{|album| album.associations[:artist] = nil}
+    #     end
+    #     id_map = eo_opts[:id_map]
+    #     rows = Artist.where(:id=>id_map.keys).all
+    #     Sequel.synchronize_with(eo[:mutex]) do
+    #       rows.each do |artist|
+    #         if albums = id_map[artist.id]
+    #           albums.each do |album|
+    #             album.associations[:artist] = artist
+    #           end
+    #         end
+    #       end
+    #     end
+    #   end)
+    #
+    # Usage:
+    #
+    #   # Make all model subclass datasets support concurrent eager loading
+    #   Sequel::Model.plugin :concurrent_eager_loading
+    #
+    #   # Make the Album class datasets support concurrent eager loading
+    #   Album.plugin :concurrent_eager_loading
+    #
+    #   # Make all model subclass datasets concurrently eager load by default
+    #   Sequel::Model.plugin :concurrent_eager_loading, always: true
+    module ConcurrentEagerLoading
+      def self.configure(mod, opts=OPTS)
+        if opts.has_key?(:always)
+          mod.instance_variable_set(:@always_eager_load_concurrently, opts[:always])
+        end
+      end
+
+      module ClassMethods
+        Plugins.inherited_instance_variables(self, :@always_eager_load_concurrently => nil)
+        Plugins.def_dataset_methods(self, [:eager_load_concurrently, :eager_load_serially])
+
+        # Whether datasets for this class should eager load concurrently by default.
+        def always_eager_load_concurrently?
+          @always_eager_load_concurrently
+        end
+      end
+
+      module DatasetMethods
+        # Return a cloned dataset that will eager load associated results concurrently
+        # using the async thread pool.
+        def eager_load_concurrently
+          cached_dataset(:_eager_load_concurrently) do
+            clone(:eager_load_concurrently=>true)
+          end
+        end
+
+        # Return a cloned dataset that will noteager load associated results concurrently
+        # using the async thread pool. Only useful if the current dataset has been marked
+        # as loading concurrently, or loading concurrently is the model's default behavior.
+        def eager_load_serially
+          cached_dataset(:_eager_load_serially) do
+            clone(:eager_load_concurrently=>false)
+          end
+        end
+
+        private
+
+        # Whether this particular dataset will eager load results concurrently.
+        def eager_load_concurrently?
+          v = @opts[:eager_load_concurrently]
+          v.nil? ? model.always_eager_load_concurrently? : v
+        end
+
+        # If performing eager loads concurrently, and at least 2 associations are being
+        # eagerly loaded, create a single mutex used for all eager loads.  After the
+        # eager loads have been performed, force loading of any async results, so that
+        # all eager loads will have been completed before this method returns.
+        def perform_eager_loads(eager_load_data)
+          return super if !eager_load_concurrently? || eager_load_data.length < 2
+
+          mutex = Mutex.new
+          eager_load_data.each_value do |eo|
+            eo[:mutex] = mutex
+          end
+
+          super.each do |v|
+            if Sequel::Database::AsyncThreadPool::BaseProxy === v
+              v.__value
+            end
+          end
+        end
+
+        # If performing eager loads concurrently, perform this eager load using the
+        # async thread pool.
+        def perform_eager_load(loader, eo)
+          eo[:mutex] ? db.send(:async_run){super} : super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/constraint_validations.rb

@@ -19,7 +19,7 @@ module Sequel
     #
     # Then when you went to save an album that uses this plugin:
     #
-    #   Album.create(:name=>'abc')
+    #   Album.create(name: 'abc')
     #   # raises Sequel::ValidationFailed: name is shorter than 5 characters
     # 
     # Usage:
@@ -39,7 +39,7 @@ module Sequel
 
       # Automatically load the validation_helpers plugin to run the actual validations.
       def self.apply(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           plugin :validation_helpers
           @constraint_validations_table = DEFAULT_CONSTRAINT_VALIDATIONS_TABLE
           @constraint_validation_options = {}
@@ -56,7 +56,7 @@ module Sequel
       #                        :presence) and values should be hashes of options specific
       #                        to that validation type.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           if table = opts[:constraint_validations_table]
             @constraint_validations_table = table
           end
@@ -72,13 +72,6 @@ module Sequel
         end
       end
 
-      module DatabaseMethods
-        # A hash of validation method call metadata for all tables in the database.
-        # The hash is keyed by table name string and contains arrays of validation
-        # method call arrays.
-        attr_accessor :constraint_validations
-      end
-
       module ClassMethods
         # An array of validation method call arrays.  Each array is an array that
         # is splatted to send to perform a validation via validation_helpers.
@@ -97,6 +90,18 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@constraint_validations_table=>nil, :@constraint_validation_options=>:hash_dup)
         Plugins.after_set_dataset(self, :parse_constraint_validations)
 
+        # Freeze constraint validations data when freezing model class.
+        def freeze
+          @constraint_validations.freeze.each(&:freeze)
+          @constraint_validation_reflections.freeze.each_value do |v|
+            v.freeze
+            v.each(&:freeze)
+          end
+          @constraint_validation_options.freeze.each_value(&:freeze)
+
+          super
+        end
+
         private
 
         # If the database has not already parsed constraint validation
@@ -106,7 +111,7 @@ module Sequel
         # If this model has associated dataset, use the model's table name
         # to get the validations for just this model.
         def parse_constraint_validations
-          db.extend(DatabaseMethods)
+          db.extension(:_model_constraint_validations)
 
           unless hash = Sequel.synchronize{db.constraint_validations}
             hash = {}
@@ -117,8 +122,7 @@ module Sequel
           end
 
           if @dataset
-            ds = @dataset.clone
-            ds.quote_identifiers = false
+            ds = @dataset.with_quote_identifiers(false)
             table_name = ds.literal(ds.first_source_table)
             reflections = {}
             @constraint_validations = (Sequel.synchronize{hash[table_name]} || []).map{|r| constraint_validation_array(r, reflections)}
@@ -216,7 +220,8 @@ module Sequel
               '%'
             when '%'
               '.*'
-            when '_'
+            else
+            #when '_'
               '.'
             end
           end
@@ -236,6 +241,7 @@ module Sequel
         def validate
           super
           model.constraint_validations.each do |v|
+            # Allow calling private validation methods
             send(*v)
           end
         end