sequel 5.11.0 → 5.12.0

data/lib/sequel/extensions/constraint_validations.rb

@@ -431,7 +431,7 @@ module Sequel
         end
       end
 
-      ds = from(:sequel_constraint_validations)
+      ds = from(constraint_validations_table)
       unless drop_rows.empty?
         ds.where([:table, :constraint_name]=>drop_rows).delete
       end

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -121,7 +121,7 @@ SQL
 
         oid_map = {}
         models.each do |model|
-          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache, true)
+          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache)
           oid_map[get(regclass_oid(model.dataset.first_source_table))] = model
         end
 
@@ -129,7 +129,7 @@ SQL
           begin
             listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge!(opts)) do |_, _, oid|
               if model = oid_map[oid.to_i]
-                model.send(:load_cache)
+                model.load_cache
               end
             end
           ensure

data/lib/sequel/model/associations.rb

@@ -633,10 +633,15 @@ module Sequel
             ds = ds.eager(associations)
           end
           if block = eo[:eager_block]
+            orig_ds = ds
             ds = block.call(ds)
           end
           if eager_loading_use_associated_key?
-            ds = ds.select_append(*associated_key_array)
+            ds = if ds.opts[:eager_graph] && !orig_ds.opts[:eager_graph]
+              block.call(orig_ds.select_append(*associated_key_array))
+            else
+              ds.select_append(*associated_key_array)
+            end
           end
           if self[:eager_graph]
             raise(Error, "cannot eagerly load a #{self[:type]} association that uses :eager_graph") if eager_loading_use_associated_key?
@@ -2949,7 +2954,7 @@ module Sequel
         # Replace the array of plain hashes with an array of model objects will all eager_graphed
         # associations set in the associations cache for each object.
         def eager_graph_build_associations(hashes)
-          hashes.replace(EagerGraphLoader.new(self).load(hashes))
+          hashes.replace(_eager_graph_build_associations(hashes, eager_graph_loader))
         end
       
         private
@@ -2960,6 +2965,12 @@ module Sequel
           clone(:join=>clone(:graph_from_self=>false).eager_graph_with_options(associations, :join_type=>type, :join_only=>true).opts[:join])
         end
 
+        # Process the array of hashes using the eager graph loader to return an array
+        # of model objects with the associations set.
+        def _eager_graph_build_associations(hashes, egl)
+          egl.load(hashes)
+        end
+
         # If the association has conditions itself, then it requires additional filters be
         # added to the current dataset to ensure that the passed in object would also be
         # included by the association's conditions.
@@ -3051,6 +3062,14 @@ module Sequel
           end
         end
       
+        # The EagerGraphLoader instance used for converting eager_graph results.
+        def eager_graph_loader
+          unless egl = cache_get(:_model_eager_graph_loader)
+            egl = cache_set(:_model_eager_graph_loader, EagerGraphLoader.new(self))
+          end
+          egl.dup
+        end
+
         # Eagerly load all specified associations 
         def eager_load(a, eager_assoc=@opts[:eager])
           return if a.empty?
@@ -3238,12 +3257,15 @@ module Sequel
               :offset
             end
           end
+          after_load_map.freeze
+          alias_map.freeze
+          type_map.freeze
 
           # Make dependency map hash out of requirements array for each association.
           # This builds a tree of dependencies that will be used for recursion
           # to ensure that all parts of the object graph are loaded into the
           # appropriate subordinate association.
-          @dependency_map = {}
+          dependency_map = @dependency_map = {}
           # Sort the associations by requirements length, so that
           # requirements are added to the dependency hash before their
           # dependencies.
@@ -3259,18 +3281,12 @@ module Sequel
               hash[ta] = {}
             end
           end
+          freezer = lambda do |h|
+            h.freeze
+            h.each_value(&freezer)
+          end
+          freezer.call(dependency_map)
       
-          # This mapping is used to make sure that duplicate entries in the
-          # result set are mapped to a single record.  For example, using a
-          # single one_to_many association with 10 associated records,
-          # the main object column values appear in the object graph 10 times.
-          # We map by primary key, if available, or by the object's entire values,
-          # if not. The mapping must be per table, so create sub maps for each table
-          # alias.
-          records_map = {@master=>{}}
-          alias_map.keys.each{|ta| records_map[ta] = {}}
-          @records_map = records_map
-
           datasets = opts[:graph][:table_aliases].to_a.reject{|ta,ds| ds.nil?}
           column_aliases = opts[:graph][:column_aliases]
           primary_keys = {}
@@ -3296,9 +3312,9 @@ module Sequel
               h.select{|ca, c| primary_keys[ta] = ca if pk == c}
             end
           end
-          @column_maps = column_maps
-          @primary_keys = primary_keys
-          @row_procs = row_procs
+          @column_maps = column_maps.freeze
+          @primary_keys = primary_keys.freeze
+          @row_procs = row_procs.freeze
 
           # For performance, create two special maps for the master table,
           # so you can skip a hash lookup.
@@ -3310,22 +3326,35 @@ module Sequel
           # used for performance, to get all values in one hash lookup instead of
           # separate hash lookups for each data structure.
           ta_map = {}
-          alias_map.keys.each do |ta|
-            ta_map[ta] = [records_map[ta], row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]]
+          alias_map.each_key do |ta|
+            ta_map[ta] = [row_procs[ta], alias_map[ta], type_map[ta], reciprocal_map[ta]].freeze
           end
-          @ta_map = ta_map
+          @ta_map = ta_map.freeze
+          freeze
         end
 
         # Return an array of primary model instances with the associations cache prepopulated
         # for all model objects (both primary and associated).
         def load(hashes)
+          # This mapping is used to make sure that duplicate entries in the
+          # result set are mapped to a single record.  For example, using a
+          # single one_to_many association with 10 associated records,
+          # the main object column values appear in the object graph 10 times.
+          # We map by primary key, if available, or by the object's entire values,
+          # if not. The mapping must be per table, so create sub maps for each table
+          # alias.
+          @records_map = records_map = {}
+          alias_map.keys.each{|ta| records_map[ta] = {}}
+
           master = master()
       
           # Assign to local variables for speed increase
           rp = row_procs[master]
-          rm = records_map[master]
+          rm = records_map[master] = {}
           dm = dependency_map
 
+          records_map.freeze
+
           # This will hold the final record set that we will be replacing the object graph with.
           records = []
 
@@ -3346,6 +3375,9 @@ module Sequel
           # Run after_load procs if there are any
           post_process(records, dm) if @unique || !after_load_map.empty? || !limit_map.empty?
 
+          records_map.each_value(&:freeze)
+          freeze
+
           records
         end
       
@@ -3365,13 +3397,14 @@ module Sequel
               end
               key = hkey(ta_h)
             end
-            rm, rp, assoc_name, tm, rcm = @ta_map[ta]
+            rp, assoc_name, tm, rcm = @ta_map[ta]
+            rm = records_map[ta]
 
             # Check type map for all dependencies, and use a unique
             # object if any are dependencies for multiple objects,
             # to prevent duplicate objects from showing up in the case
             # the normal duplicate removal code is not being used.
-            if !@unique && !deps.empty? && deps.any?{|dep_key,_| @ta_map[dep_key][3]}
+            if !@unique && !deps.empty? && deps.any?{|dep_key,_| @ta_map[dep_key][2]}
               key = [current.object_id, key]
             end
 

data/lib/sequel/model/base.rb

@@ -1415,9 +1415,9 @@ module Sequel
       # is valid and before hooks execute successfully. Fails if:
       #
       # * the record is not valid, or
-      # * before_save returns false, or
-      # * the record is new and before_create returns false, or
-      # * the record is not new and before_update returns false.
+      # * before_save calls cancel_action, or
+      # * the record is new and before_create calls cancel_action, or
+      # * the record is not new and before_update calls cancel_action.
       #
       # If +save+ fails and either raise_on_save_failure or the
       # :raise_on_failure option is true, it raises ValidationFailed

data/lib/sequel/plugins/eager_graph_eager.rb

@@ -0,0 +1,139 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The eager_graph_eager plugin allows for chaining eager loads after eager_graph
+    # loads.  Given the following model associations:
+    #
+    #   Band.one_to_many :albums
+    #   Album.one_to_many :tracks
+    #
+    # Let's say you wanted to return bands ordered by album name, and eagerly load
+    # those albums, you can do that using:
+    #
+    #   Band.eager_graph(:albums).order{albums[:name]}
+    #
+    # Let's say you also wanted to eagerly load the tracks for each album. You could
+    # just add them to the eager_graph call:
+    #  
+    #   Band.eager_graph(albums: :tracks).order{albums[:name]}
+    #
+    # However, the bloats the result set, and you aren't ordering by the track
+    # information, so a join is not required.  The eager_graph_eager plugin allows
+    # you to specify that the tracks be eagerly loaded in a separate query after
+    # the eager_graph load of albums:
+    # 
+    #   Band.eager_graph(:albums).eager_graph_eager([:albums], :tracks).order{albums[:name]}
+    #
+    # <tt>Dataset#eager_graph_eager</tt>'s first argument is a dependency chain, specified
+    # as an array of symbols.  This specifies the point at which to perform the eager load.
+    # The remaining arguments are arguments that could be passed to Dataset#eager to specify
+    # what dependent associations should be loaded at that point.
+    #
+    # If you also have the following model association:
+    #
+    #   Track.one_to_many :lyrics
+    #
+    # Here's some different ways of performing eager loading:
+    #
+    #   # 4 Queries: bands, albums, tracks, lyrics
+    #   Band.eager(albums: {tracks: :lyrics})
+    #
+    #   # 1 Query: bands+albums+tracks+lyrics
+    #   Band.eager_graph(albums: {tracks: :lyrics})
+    #
+    #   # 3 Queries: bands+albums, tracks, lyrics
+    #   Band.eager_graph(:albums).eager_graph_eager([:albums], tracks: :lyrics)
+    #
+    #   # 2 Queries: bands+albums+tracks, lyrics
+    #   Band.eager_graph(albums: :tracks).eager_graph_eager([:albums, :tracks], :lyrics)
+    #
+    #   # 2 Queries: bands+albums, tracks+lyrics
+    #   Band.eager_graph(:albums).eager_graph_eager([:albums], tracks: proc{|ds| ds.eager_graph(:lyrics)})
+    #
+    # Usage:
+    #
+    #   # Support eager_graph_eager in all subclass datasets (called before loading subclasses)
+    #   Sequel::Model.plugin :eager_graph_eager
+    #
+    #   # Support eager_graph_eager in Album class datasets
+    #   Album.plugin :eager_graph_eager
+    module EagerGraphEager
+      module DatasetMethods
+        # Specify for the given dependency chain, after loading objects for the
+        # current dataset via eager_graph, eagerly load the given associations at that point in the
+        # dependency chain.
+        #
+        # dependency_chain :: Array of association symbols, with the first association symbol
+        #                     specifying an association in the dataset's model, the next
+        #                     association specifying an association in the previous association's
+        #                     associated model, and so on.
+        # assocs :: Symbols or hashes specifying associations to eagerly load at the point
+        #           specified by the dependency chain.
+        def eager_graph_eager(dependency_chain, *assocs)
+          unless dependency_chain.is_a?(Array) && dependency_chain.all?{|s| s.is_a?(Symbol)} && !dependency_chain.empty?
+            raise Error, "eager_graph_eager first argument must be array of symbols"
+          end
+
+          current = model
+          deps = dependency_chain.map do |dep|
+            unless ref = current.association_reflection(dep)
+              raise Error, "invalid association #{dep.inspect} for #{current.inspect}"
+            end
+            current = ref.associated_class
+            [dep, ref.returns_array?]
+          end
+          assocs = current.dataset.send(:eager_options_for_associations, assocs)
+
+          deps.each(&:freeze)
+          deps.unshift(current)
+          deps.freeze
+
+          assocs.freeze
+
+          if h = @opts[:eager_graph_eager]
+            h = Hash[h]
+            h[deps] = assocs
+          else
+            h = {deps => assocs}
+          end
+
+          clone(:eager_graph_eager=>h.freeze)
+        end
+
+        protected
+
+        # After building objects from the rows, if eager_graph_eager has been
+        # called on the datasets, for each dependency chain specified, eagerly
+        # load the appropriate associations.
+        def eager_graph_build_associations(rows)
+          objects = super
+
+          if eager_data = @opts[:eager_graph_eager]
+            eager_data.each do |deps, assocs|
+              current = objects
+
+              last_class, *deps = deps
+              deps.each do |dep, is_multiple|
+                current_assocs = current.map(&:associations)
+
+                if is_multiple
+                  current = current_assocs.flat_map{|a| a[dep]}
+                else
+                  current = current_assocs.map{|a| a[dep]}
+                  current.compact!
+                end
+
+                current.uniq!(&:object_id)
+              end
+
+              last_class.dataset.send(:eager_load, current, assocs)
+            end
+          end
+
+          objects
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/static_cache.rb

@@ -55,6 +55,7 @@ module Sequel
     # Now if you +#dup+ a Model object (the resulting object is not frozen), you
     # will be able to update and save the duplicate.
     # Note the caveats around your responsibility to update the cache still applies.
+    # You can update the cache via `.load_cache` method.
     module StaticCache
       # Populate the static caches when loading the plugin. Options:
       # :frozen :: Whether retrieved model objects are frozen.  The default is true,
@@ -209,14 +210,6 @@ module Sequel
           !@static_cache_frozen
         end
 
-        private
-
-        # Return the frozen object with the given pk, or nil if no such object exists
-        # in the cache, without issuing a database query.
-        def primary_key_lookup(pk)
-          static_cache_object(cache[pk])
-        end
-
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
@@ -230,6 +223,14 @@ module Sequel
           @cache = h.freeze
         end
 
+        private
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def primary_key_lookup(pk)
+          static_cache_object(cache[pk])
+        end
+
         # If frozen: false is not used, just return the argument. Otherwise,
         # create a new instance with the arguments values if the argument is
         # not nil.

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -60,6 +60,46 @@ module Sequel
     #   # SELECT * FROM artists WHERE name > 'N' AND id IN (...)
     #   albums.first.artists(eager: lambda{|ds| ds.where(Sequel[:name] > 'N')})
     #
+    # The tactical_eager_loading plugin also allows transparent eager
+    # loading when calling association methods on associated objects
+    # eagerly loaded via Dataset#eager_graph.  This can reduce N queries
+    # to a single query when iterating over all associated objects.
+    # Consider the following code:
+    #
+    #   artists = Artist.eager_graph(:albums).all
+    #   artists.each do |artist|
+    #     artist.albums.each do |album|
+    #       album.tracks
+    #     end
+    #   end
+    #
+    # By default this will issue a single query to load the artists and
+    # albums, and then one query for each album to load the tracks for
+    # the album:
+    #
+    #   # SELECT artists.id, ...
+    #            albums.id, ...
+    #   # FROM artists
+    #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
+    #   # SELECT * FROM tracks WHERE album_id = 1;
+    #   # SELECT * FROM tracks WHERE album_id = 2;
+    #   # SELECT * FROM tracks WHERE album_id = 10;
+    #   # ...
+    #
+    # With the tactical_eager_loading plugin, this uses the same
+    # query to load the artists and albums, but then issues a single query
+    # to load the tracks for all albums.
+    #
+    #   # SELECT artists.id, ...
+    #            albums.id, ...
+    #   # FROM artists
+    #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
+    #   # SELECT * FROM tracks WHERE (tracks.album_id IN (1, 2, 10, ...));
+    #
+    # Note that transparent eager loading for associated objects
+    # loaded by eager_graph will only take place if the associated classes
+    # also use the tactical_eager_loading plugin.
+    #
     # Usage:
     #
     #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)
@@ -112,7 +152,29 @@ module Sequel
       module DatasetMethods
         private
 
-        # Set the retrieved_with and retrieved_by attributes for the object
+        # Set the retrieved_with and retrieved_by attributes for each of the associated objects
+        # created by the eager graph loader with the appropriate class dataset and array of objects.
+        def _eager_graph_build_associations(_, egl)
+          objects = super
+
+          master = egl.master
+          egl.records_map.each do |k, v|
+            next if k == master || v.empty?
+
+            by = opts[:graph][:table_aliases][k]
+            values = v.values
+
+            values.each do |o|
+              next unless o.is_a?(TacticalEagerLoading::InstanceMethods) && !o.retrieved_by
+              o.retrieved_by = by
+              o.retrieved_with = values
+            end
+          end
+
+          objects
+        end
+
+        # Set the retrieved_with and retrieved_by attributes for each object
         # with the current dataset and array of all objects.
         def post_load(objects)
           super