sequel 5.43.0 → 5.44.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69c695b559f3d5c19284905e8bad5a8775cced221f5cd3f5bb1d89daa9c0785c
-  data.tar.gz: 03cd2d01139038c3e6d1e1232f6b48a104657391aeefd82feab2636044480eba
+  metadata.gz: 84b971e8db174387861ce5ccbb36f43ba2ffa39a8b5f88359c1246eac5ff1539
+  data.tar.gz: d90034f07d752fc45f6359d9b38708e865200c1a1f0c9a1ea77c9d24d681e0a3
 SHA512:
-  metadata.gz: 4b6f0b096657603c11cf54b1b15b660c5b85a697e8b31b69f97f33d579401a73915a315b771467e56159313243c5643bb3ca5fd8c208f2c443d8c7536cba9fc0
-  data.tar.gz: 1a44276ab427bc2f9a82e2f651950100360df998af75a9d3ca08618acfa3778b02764f544738569c5947b350ac8b2485b825052869ac882728707014e90633a8
+  metadata.gz: 194b8b093ecc8c18b228a19b1c27b21535590de8ac5d5002af1038ee28add4a8afdf31741bd33a5838c94535ec272cbb594e6674d76dcdd99518f5e3cbca4dda
+  data.tar.gz: cb54772e671e6c82422e6f4b076b3c7748165837d3501834ddc374cf939c4ea08cc581876150be72c3532a0f3591aaef18e4858e00493db0b49724a1257da957

data/CHANGELOG

@@ -1,3 +1,13 @@
+=== 5.44.0 (2021-05-01)
+
+* Add concurrent_eager_loading plugin, for eager loading multiple associations concurrently using separate threads (jeremyevans)
+
+* Support :weeks as a interval unit in the date_arithmetic extension (jeremyevans) (#1759)
+
+* Raise an exception if an interval hash with an unsupported key is passed in the date_arithmetic extension (jeremyevans) (#1759)
+
+* Support dropping non-composite unique constraints on SQLite (jeremyevans) (#1755)
+
 === 5.43.0 (2021-04-01)
 
 * Add column_encryption plugin, for encrypting column values (jeremyevans)

data/doc/release_notes/5.44.0.txt

@@ -0,0 +1,32 @@
+= New Features
+
+* A concurrent_eager_loading plugin has been added.  This plugin
+  builds on top of the async_thread_pool Database extension and
+  allows eager loading multiple associations concurrently in
+  separate threads.  With this plugin, you can mark datasets for
+  concurrent eager loading using eager_load_concurrently:
+
+    Album.eager_load_concurrently.eager(:artist, :genre, :tracks).all
+
+  Datasets that are marked for concurrent eager loading will use
+  concurrent eager loading if they are eager loading more than one
+  association.  If you would like to make concurrent eager loading
+  the default, you can load the plugin with the :always option.
+
+  All of the association types that ship with Sequel now support
+  concurrent eager loading when using this plugin. For custom eager
+  loaders using the :eager_loader association option, please see the
+  documentation for the plugin for how to enable custom eager loading
+  for them.
+
+= Other Improvements
+
+* The date_arithmetic extension now handles ActiveSupport::Duration
+  values with weeks, as well as :weeks as a key in a hash value. Weeks
+  are converted into 7 days internally.
+
+* The shared SQLite adapter now emulates the dropping of non-composite
+  unique constraints.  Non-composite unique constraints are now
+  treated similarly to composite unique constraints, in that dropping
+  any unique constraints on a table will drop all unique constraints
+  on that table.

data/doc/testing.rdoc

@@ -162,6 +162,7 @@ SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when run
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
+SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs

data/lib/sequel/adapters/shared/sqlite.rb

@@ -424,10 +424,10 @@ module Sequel
         skip_indexes = []
         indexes(table, :only_autocreated=>true).each do |name, h|
           skip_indexes << name
-          if h[:unique]
+          if h[:unique] && !opts[:no_unique]
             if h[:columns].length == 1
               unique_columns.concat(h[:columns])
-            elsif h[:columns].map(&:to_s) != pks && !opts[:no_unique]
+            elsif h[:columns].map(&:to_s) != pks
               constraints << {:type=>:unique, :columns=>h[:columns]}
             end
           end

data/lib/sequel/core.rb

@@ -176,6 +176,17 @@ module Sequel
       JSON.parse(json, :create_additions=>false)
     end
 
+    # If a mutex is given, synchronize access using it.  If nil is given, just
+    # yield to the block.  This is designed for cases where a mutex may or may
+    # not be provided.
+    def synchronize_with(mutex)
+      if mutex
+        mutex.synchronize{yield}
+      else
+        yield
+      end
+    end
+
     # Convert each item in the array to the correct type, handling multi-dimensional
     # arrays.  For each element in the array or subarrays, call the converter,
     # unless the value is nil.

data/lib/sequel/database/schema_generator.rb

@@ -214,14 +214,12 @@ module Sequel
       end
 
       # Add a full text index on the given columns.
+      # See #index for additional options.
       #
       # PostgreSQL specific options:
       # :index_type :: Can be set to :gist to use a GIST index instead of the
       #                default GIN index.
       # :language :: Set a language to use for the index (default: simple).
-      #
-      # Microsoft SQL Server specific options:
-      # :key_index :: The KEY INDEX to use for the full text index.
       def full_text_index(columns, opts = OPTS)
         index(columns, opts.merge(:type => :full_text))
       end
@@ -231,35 +229,43 @@ module Sequel
         columns.any?{|c| c[:name] == name}
       end
       
-      # Add an index on the given column(s) with the given options.
+      # Add an index on the given column(s) with the given options. Examples:
+      #
+      #   index :name
+      #   # CREATE INDEX table_name_index ON table (name)
+      #
+      #   index [:artist_id, :name]
+      #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
+      #
+      #   index [:artist_id, :name], name: :foo
+      #   # CREATE INDEX foo ON table (artist_id, name)
+      #
       # General options:
       #
+      # :include :: Include additional column values in the index, without
+      #             actually indexing on those values (only supported by
+      #             some databases).
       # :name :: The name to use for the index. If not given, a default name
       #          based on the table and columns is used.
-      # :type :: The type of index to use (only supported by some databases)
+      # :type :: The type of index to use (only supported by some databases,
+      #          :full_text and :spatial values are handled specially).
       # :unique :: Make the index unique, so duplicate values are not allowed.
-      # :where :: Create a partial index (only supported by some databases)
+      # :where :: A filter expression, used to create a partial index (only
+      #           supported by some databases).
       #
       # PostgreSQL specific options:
       #
       # :concurrently :: Create the index concurrently, so it doesn't block
       #                  operations on the table while the index is being
       #                  built.
-      # :opclass :: Use a specific operator class in the index.
-      # :include :: Include additional column values in the index, without
-      #             actually indexing on those values (PostgreSQL 11+).
+      # :if_not_exists :: Only create the index if an index of the same name doesn't already exist.
+      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
+      #             custom SQL).
       # :tablespace :: Specify tablespace for index.
       #
       # Microsoft SQL Server specific options:
       #
-      # :include :: Include additional column values in the index, without
-      #             actually indexing on those values.
-      #
-      #   index :name
-      #   # CREATE INDEX table_name_index ON table (name)
-      #
-      #   index [:artist_id, :name]
-      #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
+      # :key_index :: Sets the KEY INDEX to the given value.
       def index(columns, opts = OPTS)
         indexes << {:columns => Array(columns)}.merge!(opts)
         nil
@@ -325,6 +331,7 @@ module Sequel
       end
       
       # Add a spatial index on the given columns.
+      # See #index for additional options.
       def spatial_index(columns, opts = OPTS)
         index(columns, opts.merge(:type => :spatial))
       end
@@ -451,7 +458,7 @@ module Sequel
       end
       
       # Add a full text index on the given columns.
-      # See CreateTableGenerator#index for available options.
+      # See CreateTableGenerator#full_text_index for available options.
       def add_full_text_index(columns, opts = OPTS)
         add_index(columns, {:type=>:full_text}.merge!(opts))
       end
@@ -460,34 +467,6 @@ module Sequel
       # CreateTableGenerator#index for available options.
       #
       #   add_index(:artist_id) # CREATE INDEX table_artist_id_index ON table (artist_id)
-      #
-      # Options:
-      #
-      # :name :: Give a specific name for the index. Highly recommended if you plan on
-      #          dropping the index later.
-      # :where :: A filter expression, used to setup a partial index (if supported).
-      # :unique :: Create a unique index.
-      #
-      # PostgreSQL specific options:
-      #
-      # :concurrently :: Create the index concurrently, so it doesn't require an exclusive lock
-      #                  on the table.
-      # :index_type :: The underlying index type to use for a full_text index, gin by default).
-      # :language :: The language to use for a full text index (simple by default).
-      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
-      #             custom SQL).
-      # :type :: Set the index type (e.g. full_text, spatial, hash, gin, gist, btree).
-      # :if_not_exists :: Only create the index if an index of the same name doesn't already exists
-      #
-      # MySQL specific options:
-      #
-      # :type :: Set the index type, with full_text and spatial indexes handled specially.
-      #
-      # Microsoft SQL Server specific options:
-      #
-      # :include :: Includes additional columns in the index.
-      # :key_index :: Sets the KEY INDEX to the given value.
-      # :type :: clustered uses a clustered index, full_text uses a full text index.
       def add_index(columns, opts = OPTS)
         @operations << {:op => :add_index, :columns => Array(columns)}.merge!(opts)
         nil

data/lib/sequel/extensions/date_arithmetic.rb

@@ -8,9 +8,10 @@
 #   DB.extension :date_arithmetic
 #
 # Then you can use the Sequel.date_add and Sequel.date_sub methods
-# to return Sequel expressions:
+# to return Sequel expressions (this example shows the only supported
+# keys for the second argument):
 #
-#   add = Sequel.date_add(:date_column, years: 1, months: 2, days: 3)
+#   add = Sequel.date_add(:date_column, years: 1, months: 2, weeks: 2, days: 1)
 #   sub = Sequel.date_sub(:date_column, hours: 1, minutes: 2, seconds: 3)
 #
 # In addition to specifying the interval as a hash, there is also
@@ -184,22 +185,35 @@ module Sequel
       # ActiveSupport::Duration :: Converted to a hash using the interval's parts.
       def initialize(expr, interval, opts=OPTS)
         @expr = expr
-        @interval = if interval.is_a?(Hash)
-          interval.each_value do |v|
-             # Attempt to prevent SQL injection by users who pass untrusted strings
-             # as interval values. 
-             if v.is_a?(String) && !v.is_a?(LiteralString)
-               raise Sequel::InvalidValue, "cannot provide String value as interval part: #{v.inspect}"
-             end
+
+        h = Hash.new(0)
+        interval = interval.parts unless interval.is_a?(Hash)
+        interval.each do |unit, value|
+          # skip nil values
+          next unless value
+
+          # Convert weeks to days, as ActiveSupport::Duration can use weeks,
+          # but the database-specific literalizers only support days.
+          if unit == :weeks
+            unit = :days
+            value *= 7
+          end
+
+          unless DatasetMethods::DURATION_UNITS.include?(unit)
+            raise Sequel::Error, "Invalid key used in DateAdd interval hash: #{unit.inspect}"
           end
-          Hash[interval]
-        else
-          h = Hash.new(0)
-          interval.parts.each{|unit, value| h[unit] += value}
-          Hash[h]
+
+          # Attempt to prevent SQL injection by users who pass untrusted strings
+          # as interval values. It doesn't make sense to support literal strings,
+          # due to the numeric adding below.
+          if value.is_a?(String)
+            raise Sequel::InvalidValue, "cannot provide String value as interval part: #{value.inspect}"
+          end
+
+          h[unit] += value
         end
 
-        @interval.freeze
+        @interval = Hash[h].freeze
         @cast_type = opts[:cast] if opts[:cast]
         freeze
       end

data/lib/sequel/extensions/pg_enum.rb

@@ -42,7 +42,7 @@
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of enum types, load the pg_array extension before the
-# pg_interval extension:
+# pg_enum extension:
 #
 #   DB.extension :pg_array, :pg_enum
 #

data/lib/sequel/model/associations.rb

@@ -263,7 +263,9 @@ module Sequel
         # yielding each row to the block.
         def eager_load_results(eo, &block)
           rows = eo[:rows]
-          initialize_association_cache(rows) unless eo[:initialize_rows] == false
+          unless eo[:initialize_rows] == false
+            Sequel.synchronize_with(eo[:mutex]){initialize_association_cache(rows)}
+          end
           if eo[:id_map]
             ids = eo[:id_map].keys
             return ids if ids.empty?
@@ -311,7 +313,8 @@ module Sequel
             objects = loader.all(ids)
           end
 
-          objects.each(&block)
+          Sequel.synchronize_with(eo[:mutex]){objects.each(&block)}
+
           if strategy == :ruby
             apply_ruby_eager_limit_strategy(rows, eager_limit || limit_and_offset)
           end
@@ -3374,15 +3377,30 @@ module Sequel
           egl.dup
         end
 
-        # Eagerly load all specified associations 
+        # Eagerly load all specified associations.
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
+
+          # Reflections for all associations to eager load
+          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
+
+          perform_eager_loads(prepare_eager_load(a, reflections, eager_assoc))
+
+          reflections.each do |r|
+            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
+          end 
+
+          nil
+        end
+
+        # Prepare a hash loaders and eager options which will be used to implement the eager loading.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          eager_load_data = {}
+
           # Key is foreign/primary key name symbol.
           # Value is hash with keys being foreign/primary key values (generally integers)
           # and values being an array of current model objects with that specific foreign/primary key
           key_hash = {}
-          # Reflections for all associations to eager load
-          reflections = eager_assoc.keys.map{|assoc| model.association_reflection(assoc) || (raise Sequel::UndefinedAssociation, "Model: #{self}, Association: #{assoc}")}
       
           # Populate the key_hash entry for each association being eagerly loaded
           reflections.each do |r|
@@ -3413,7 +3431,6 @@ module Sequel
               id_map = nil
             end
           
-            loader = r[:eager_loader]
             associations = eager_assoc[r[:name]]
             if associations.respond_to?(:call)
               eager_block = associations
@@ -3421,9 +3438,23 @@ module Sequel
             elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
               eager_block, associations = pr_assoc
             end
-            loader.call(:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map)
-            a.each{|object| object.send(:run_association_callbacks, r, :after_load, object.associations[r[:name]])} if r[:after_load]
-          end 
+
+            eager_load_data[r[:eager_loader]] = {:key_hash=>key_hash, :rows=>a, :associations=>associations, :self=>self, :eager_block=>eager_block, :id_map=>id_map}
+          end
+
+          eager_load_data
+        end
+
+        # Using the hash of loaders and eager options, perform the eager loading.
+        def perform_eager_loads(eager_load_data)
+          eager_load_data.map do |loader, eo|
+            perform_eager_load(loader, eo)
+          end
+        end
+
+        # Perform eager loading for a single association using the loader and eager options.
+        def perform_eager_load(loader, eo)
+          loader.call(eo)
         end
 
         # Return a subquery expression for filering by a many_to_many association

data/lib/sequel/plugins/async_thread_pool.rb

@@ -5,7 +5,7 @@ module Sequel
 
   module Plugins
     # The async_thread_pool plugin makes it slightly easier to use the async_thread_pool
-    # Dataset extension with models.  It makes Model.async return an async dataset for the
+    # Database extension with models.  It makes Model.async return an async dataset for the
     # model, and support async behavior for #destroy, #with_pk, and #with_pk! for model
     # datasets:
     #

data/lib/sequel/plugins/column_encryption.rb

@@ -7,10 +7,27 @@ raise(Sequel::Error, "Sequel column_encryption plugin requires ruby 2.3 or great
 require 'openssl'
 
 begin
-  OpenSSL::Cipher.new("aes-256-gcm")
-rescue OpenSSL::Cipher::CipherError
+  # Test cipher actually works
+  cipher = OpenSSL::Cipher.new("aes-256-gcm")
+  cipher.encrypt
+  cipher.key = '1'*32
+  cipher_iv = cipher.random_iv
+  cipher.auth_data = ''
+  cipher_text = cipher.update('2') << cipher.final
+  auth_tag = cipher.auth_tag
+
+  cipher = OpenSSL::Cipher.new("aes-256-gcm")
+  cipher.decrypt
+  cipher.iv = cipher_iv
+  cipher.key = '1'*32
+  cipher.auth_data = ''
+  cipher.auth_tag = auth_tag
   # :nocov:
-  raise LoadError, "Sequel column_encryption plugin requires the aes-256-gcm cipher"
+  unless (cipher.update(cipher_text) << cipher.final) == '2'
+    raise OpenSSL::Cipher::CipherError
+  end
+rescue RuntimeError, OpenSSL::Cipher::CipherError
+  raise LoadError, "Sequel column_encryption plugin requires a working aes-256-gcm cipher"
   # :nocov:
 end
 

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/pg_array_associations.rb

@@ -426,10 +426,12 @@ module Sequel
             id_map = {}
             pkm = opts.primary_key_method
 
-            rows.each do |object|
-              if associated_pks = object.get_column_value(key)
-                associated_pks.each do |apk|
-                  (id_map[apk] ||= []) << object
+            Sequel.synchronize_with(eo[:mutex]) do
+              rows.each do |object|
+                if associated_pks = object.get_column_value(key)
+                  associated_pks.each do |apk|
+                    (id_map[apk] ||= []) << object
+                  end
                 end
               end
             end

data/lib/sequel/plugins/rcte_tree.rb

@@ -170,11 +170,13 @@ module Sequel
           id_map = eo[:id_map]
           parent_map = {}
           children_map = {}
-          eo[:rows].each do |obj|
-            parent_map[prkey_conv[obj]] = obj
-            (children_map[key_conv[obj]] ||= []) << obj
-            obj.associations[ancestors] = []
-            obj.associations[parent] = nil
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              (children_map[key_conv[obj]] ||= []) << obj
+              obj.associations[ancestors] = []
+              obj.associations[parent] = nil
+            end
           end
           r = model.association_reflection(ancestors)
           base_case = model.where(prkey=>id_map.keys).
@@ -207,10 +209,12 @@ module Sequel
               root.associations[ancestors] << obj
             end
           end
-          parent_map.each do |parent_id, obj|
-            if children = children_map[parent_id]
-              children.each do |child|
-                child.associations[parent] = obj
+          Sequel.synchronize_with(eo[:mutex]) do
+            parent_map.each do |parent_id, obj|
+              if children = children_map[parent_id]
+                children.each do |child|
+                  child.associations[parent] = obj
+                end
               end
             end
           end
@@ -268,10 +272,12 @@ module Sequel
           associations = eo[:associations]
           parent_map = {}
           children_map = {}
-          eo[:rows].each do |obj|
-            parent_map[prkey_conv[obj]] = obj
-            obj.associations[descendants] = []
-            obj.associations[childrena] = []
+          Sequel.synchronize_with(eo[:mutex]) do
+            eo[:rows].each do |obj|
+              parent_map[prkey_conv[obj]] = obj
+              obj.associations[descendants] = []
+              obj.associations[childrena] = []
+            end
           end
           r = model.association_reflection(descendants)
           base_case = model.where(key=>id_map.keys).
@@ -316,12 +322,14 @@ module Sequel
             
             (children_map[key_conv[obj]] ||= []) << obj
           end
-          children_map.each do |parent_id, objs|
-            objs = objs.uniq
-            parent_obj = parent_map[parent_id]
-            parent_obj.associations[childrena] = objs
-            objs.each do |obj|
-              obj.associations[parent] = parent_obj
+          Sequel.synchronize_with(eo[:mutex]) do
+            children_map.each do |parent_id, objs|
+              objs = objs.uniq
+              parent_obj = parent_map[parent_id]
+              parent_obj.associations[childrena] = objs
+              objs.each do |obj|
+                obj.associations[parent] = parent_obj
+              end
             end
           end
         end

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 43
+  MINOR = 44
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.43.0
+  version: 5.44.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-01 00:00:00.000000000 Z
+date: 2021-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -187,6 +187,7 @@ extra_rdoc_files:
 - doc/release_notes/5.41.0.txt
 - doc/release_notes/5.42.0.txt
 - doc/release_notes/5.43.0.txt
+- doc/release_notes/5.44.0.txt
 - doc/release_notes/5.5.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
@@ -258,6 +259,7 @@ files:
 - doc/release_notes/5.41.0.txt
 - doc/release_notes/5.42.0.txt
 - doc/release_notes/5.43.0.txt
+- doc/release_notes/5.44.0.txt
 - doc/release_notes/5.5.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
@@ -465,6 +467,7 @@ files:
 - lib/sequel/plugins/column_select.rb
 - lib/sequel/plugins/columns_updated.rb
 - lib/sequel/plugins/composition.rb
+- lib/sequel/plugins/concurrent_eager_loading.rb
 - lib/sequel/plugins/constraint_validations.rb
 - lib/sequel/plugins/csv_serializer.rb
 - lib/sequel/plugins/dataset_associations.rb
@@ -566,7 +569,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby