sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/csv_serializer.rb

@@ -1,42 +1,35 @@
 # frozen-string-literal: true
 
-if RUBY_VERSION < "1.9"
-  # :nocov:
-  require 'fastercsv'
-  # :nocov:
-else
-  require 'csv'
-end
+require 'csv'
 
 module Sequel
   module Plugins
     # csv_serializer handles serializing entire Sequel::Model objects to CSV,
     # as well as support for deserializing CSV directly into Sequel::Model
-    # objects.  It requires either the csv standard library when usnig ruby 1.9+,
-    # or the fastercsv gem when using ruby 1.8.
+    # objects.  It requires the csv standard library.
     #
     # Basic Example:
     #
     #   album = Album[1]
-    #   album.to_csv(:write_headers=>true)
+    #   album.to_csv(write_headers: true)
     #   # => "id,name,artist_id\n1,RF,2\n"
     #
     # You can provide options to control the CSV output:
     #
-    #   album.to_csv(:only=>:name)
-    #   album.to_csv(:except=>[:id, :artist_id])
+    #   album.to_csv(only: :name)
+    #   album.to_csv(except: [:id, :artist_id])
     #   # => "RF\n"
     #
     # +to_csv+ also exists as a class and dataset method, both of which return
     # all objects in the dataset:
     #
     #   Album.to_csv
-    #   Album.filter(:artist_id=>1).to_csv
+    #   Album.where(artist_id: 1).to_csv
     #
-    # If you have an existing array of model instance you want to convert to
+    # If you have an existing array of model instances you want to convert to
     # CSV, you can call the class to_csv method with the :array option:
     #
-    #   Album.to_csv(:array=>[Album[1], Album[2]])
+    #   Album.to_csv(array: [Album[1], Album[2]])
     #
     # In addition to creating CSV, this plugin also enables Sequel::Model
     # classes to create instances directly from CSV using the from_csv class
@@ -48,7 +41,7 @@ module Sequel
     # The array_from_csv class method exists to parse arrays of model instances
     # from CSV:
     #
-    #   csv = Album.filter(:artist_id=>1).to_csv
+    #   csv = Album.where(artist_id: 1).to_csv
     #   albums = Album.array_from_csv(csv)
     #
     # These do not necessarily round trip, since doing so would let users
@@ -56,7 +49,7 @@ module Sequel
     # call set with the values in the hash.  If you want to specify the allowed
     # fields, you can use the :headers option.
     #
-    #   Album.from_csv(album.to_csv, :headers=>%w'id name')
+    #   Album.from_csv(album.to_csv, headers: %w'id name')
     #
     # If you want to update an existing instance, you can use the from_csv
     # instance method:
@@ -72,14 +65,30 @@ module Sequel
     #   # Add CSV output capability to Album class instances
     #   Album.plugin :csv_serializer
     module CsvSerializer
-      CSV = Object.const_defined?(:CSV) ? ::CSV : ::FasterCSV
-
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values
-      def self.configure(model, opts = {})
-        model.instance_eval do
-          @csv_serializer_opts = (@csv_serializer_opts || {}).merge(opts)
+      def self.configure(model, opts = OPTS)
+        model.instance_exec do
+          @csv_serializer_opts = (@csv_serializer_opts || OPTS).merge(opts)
+        end
+      end
+
+      # Avoid keyword argument separation warnings on Ruby 2.7, while still
+      # being compatible with 1.9.
+      if RUBY_VERSION >= "2.0"
+        instance_eval(<<-END, __FILE__, __LINE__+1)
+          def self.csv_call(*args, opts, &block)
+            CSV.send(*args, **opts, &block)
+          end
+        END
+      else
+        # :nocov:
+        # :nodoc:
+        def self.csv_call(*args, opts, &block)
+          CSV.send(*args, opts, &block)
         end
+        # :nodoc:
+        # :nocov:
       end
 
       module ClassMethods
@@ -87,26 +96,36 @@ module Sequel
         attr_reader :csv_serializer_opts
 
         # Attempt to parse an array of instances from the given CSV string
-        def array_from_csv(csv, opts = {})
-          CSV.parse(csv, process_csv_serializer_opts(opts)).map do |row|
+        def array_from_csv(csv, opts = OPTS)
+          CsvSerializer.csv_call(:parse, csv, process_csv_serializer_opts(opts)).map do |row|
             row = row.to_hash
             row.delete(nil)
             new(row)
           end
         end
 
+        # Freeze csv serializier opts when freezing model class
+        def freeze
+          @csv_serializer_opts.freeze.each_value do |v|
+            v.freeze if v.is_a?(Array) || v.is_a?(Hash)
+          end
+
+          super
+        end
+
         # Attempt to parse a single instance from the given CSV string
-        def from_csv(csv, opts = {})
+        def from_csv(csv, opts = OPTS)
           new.from_csv(csv, opts)
         end
 
         # Convert the options hash to one that can be passed to CSV.
         def process_csv_serializer_opts(opts)
-          opts = (csv_serializer_opts || {}).merge(opts)
+          opts = (csv_serializer_opts || OPTS).merge(opts)
           opts_cols = opts.delete(:columns)
           opts_include = opts.delete(:include)
           opts_except = opts.delete(:except)
-          opts[:headers] ||= Array(opts.delete(:only) || opts_cols || columns) + Array(opts_include) - Array(opts_except)
+          only = opts.delete(:only) 
+          opts[:headers] ||= Array(only || opts_cols || columns) + Array(opts_include) - Array(opts_except)
           opts
         end
 
@@ -127,8 +146,8 @@ module Sequel
         #
         # :headers :: The headers to use for the CSV line. Use nil for a header
         #             to specify the column should be ignored.
-        def from_csv(csv, opts = {})
-          row = CSV.parse_line(csv, model.process_csv_serializer_opts(opts)).to_hash
+        def from_csv(csv, opts = OPTS)
+          row = CsvSerializer.csv_call(:parse_line, csv, model.process_csv_serializer_opts(opts)).to_hash
           row.delete(nil)
           set(row)
         end
@@ -142,11 +161,12 @@ module Sequel
         #          output, ignoring all other columns
         # :include :: Symbol or Array of Symbols specifying non-column
         #             attributes to include in the CSV output.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts(opts)
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
-            csv << opts[:headers].map{|k| send(k)}
+          CsvSerializer.csv_call(:generate, model.process_csv_serializer_opts(opts)) do |csv|
+            csv << headers.map{|k| public_send(k)}
           end
         end
       end
@@ -159,13 +179,14 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided, calls #all
         #           on the receiver to get the array.
-        def to_csv(opts = {})
+        def to_csv(opts = OPTS)
           opts = model.process_csv_serializer_opts({:columns=>columns}.merge!(opts))
           items = opts.delete(:array) || self
+          headers = opts[:headers]
 
-          CSV.generate(opts) do |csv|
+          CsvSerializer.csv_call(:generate, opts) do |csv|
             items.each do |object|
-              csv << opts[:headers].map{|header| object.send(header) }
+              csv << headers.map{|header| object.public_send(header)}
             end
           end
         end

data/lib/sequel/plugins/dataset_associations.rb

@@ -12,7 +12,7 @@ module Sequel
     #     plugin :dataset_associations
     #     one_to_many :albums
     #   end
-    #   Artist.filter(id=>1..100).albums
+    #   Artist.where(id: 1..100).albums
     #   # SELECT * FROM albums
     #   # WHERE (albums.artist_id IN (
     #   #   SELECT id FROM artists
@@ -27,7 +27,7 @@ module Sequel
     # As the dataset methods return datasets, you can easily chain the
     # methods to get associated datasets of associated datasets:
     #
-    #   Artist.filter(id=>1..100).albums.filter{name < 'M'}.tags
+    #   Artist.where(id: 1..100).albums.where{name < 'M'}.tags
     #   # SELECT tags.* FROM tags
     #   # WHERE (tags.id IN (
     #   #   SELECT albums_tags.tag_id FROM albums
@@ -62,7 +62,10 @@ module Sequel
           ret = super
           r = association_reflection(name)
           meth = r.returns_array? ? name : pluralize(name).to_sym
-          def_dataset_method(meth){associated(name)}
+          dataset_module do
+            define_method(meth){associated(name)}
+            alias_method(meth, meth)
+          end
           ret
         end
 
@@ -83,29 +86,49 @@ module Sequel
           sds = opts[:limit] ? self : unordered
           ds = case r[:type]
           when :many_to_one
-            ds.filter(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
+            ds.where(r.qualified_primary_key=>sds.select(*Array(r[:qualified_key])))
           when :one_to_one, :one_to_many
-            r.send(:apply_filter_by_associations_limit_strategy, ds.filter(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
+            r.send(:apply_filter_by_associations_limit_strategy, ds.where(r.qualified_key=>sds.select(*Array(r.qualified_primary_key))))
           when :many_to_many, :one_through_one
             mds = r.associated_class.dataset.
               join(r[:join_table], r[:right_keys].zip(r.right_primary_keys)).
               select(*Array(r.qualified_right_key)).
               where(r.qualify(r.join_table_alias, r[:left_keys])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+            ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :many_through_many, :one_through_many
-            fre = r.reverse_edges.first
-            fe, *edges = r.edges
-            edges << r.final_edge
-            mds = model.
-              select(*Array(r.qualify(fre[:table], fre[:left]))).
-              join(fe[:table], Array(fe[:right]).zip(Array(fe[:left])), :implicit_qualifier=>model.table_name).
-              where(r.qualify(fe[:table], fe[:right])=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
-            edges.each{|e| mds = mds.join(e[:table], Array(e[:right]).zip(Array(e[:left])))}
-            ds.filter(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
+            if r.reverse_edges.empty?
+              mds = r.associated_dataset
+              fe = r.edges.first
+              selection = Array(r.qualify(fe[:table], r.final_edge[:left]))
+              predicate_key = r.qualify(fe[:table], fe[:right])
+            else
+              mds = model.dataset
+              iq = model.table_name
+              edges = r.edges.map(&:dup)
+              edges << r.final_edge.dup
+              edges.each do |e|
+                alias_expr = e[:table]
+                aliaz = mds.unused_table_alias(e[:table])
+                unless aliaz == alias_expr
+                  alias_expr = Sequel.as(e[:table], aliaz)
+                end
+                e[:alias] = aliaz
+                mds = mds.join(alias_expr, Array(e[:right]).zip(Array(e[:left])), :implicit_qualifier=>iq)
+                iq = nil
+              end
+              fe, f1e, f2e = edges.values_at(0, -1, -2)
+              selection = Array(r.qualify(f2e[:alias], f1e[:left]))
+              predicate_key = r.qualify(fe[:alias], fe[:right])
+            end
+
+            mds = mds.
+              select(*selection).
+              where(predicate_key=>sds.select(*r.qualify(model.table_name, r[:left_primary_key_columns])))
+            ds.where(r.qualified_right_primary_key=>r.send(:apply_filter_by_associations_limit_strategy, mds))
           when :pg_array_to_many
-            ds.filter(Sequel.expr(r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}))
+            ds.where(Sequel[r.primary_key=>sds.select{Sequel.pg_array_op(r.qualify(r[:model].table_name, r[:key])).unnest}])
           when :many_to_pg_array
-            ds.filter(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
+            ds.where(Sequel.function(:coalesce, Sequel.pg_array_op(r[:key]).overlaps(sds.select{array_agg(r.qualify(r[:model].table_name, r.primary_key))}), false))
           else
             raise Error, "unrecognized association type for association #{name.inspect}: #{r[:type].inspect}"
           end

data/lib/sequel/plugins/def_dataset_method.rb

@@ -0,0 +1,90 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The def_dataset_method plugin adds Model.def_dataset_method
+    # for defining dataset methods:
+    #
+    #   Album.def_dataset_method(:by_name) do |name|
+    #     where(name: name)
+    #   end
+    #
+    # Additionally, this adds support for Model.subset, which can also
+    # be used to define dataset methods that add specific filters:
+    #
+    #   Album.subset(:gold){copies_sold >= 500000}
+    #
+    # This exists for backwards compatibility with previous Sequel versions.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support Model.def_dataset_method
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :def_dataset_method
+    #
+    #   # Make the Album class support Model.def_dataset_method
+    #   Album.plugin :def_dataset_method
+    module DefDatasetMethod
+      module ClassMethods
+        # If a block is given, define a method on the dataset (if the model currently has an dataset)  with the given argument name using
+        # the given block.  Also define a class method on the model that calls the
+        # dataset method.  Stores the method name and block so that it can be reapplied if the model's
+        # dataset changes.
+        #
+        # If a block is not given, just define a class method on the model for each argument
+        # that calls the dataset method of the same argument name.
+        #
+        # Using dataset_module is recommended over using this method.  In addition to allowing
+        # more natural ruby syntax for defining methods manually, it also offers numerous
+        # helper methods that make defining common dataset methods more easily, as well as
+        # supporting dataset caching (assuming the arguments allow it).
+        #
+        #   # Add new dataset method and class method that calls it
+        #   Artist.def_dataset_method(:by_name){order(:name)}
+        #   Artist.where(Sequel[:name].like('A%')).by_name
+        #   Artist.by_name.where(Sequel[:name].like('A%'))
+        #
+        #   # Just add a class method that calls an existing dataset method
+        #   Artist.def_dataset_method(:paginate)
+        #   Artist.paginate(2, 10)
+        def def_dataset_method(*args, &block)
+          raise(Error, "No arguments given") if args.empty?
+
+          if block
+            raise(Error, "Defining a dataset method using a block requires only one argument") if args.length > 1
+            dataset_module{define_method(args.first, &block)}
+          else
+            args.each{|arg| def_model_dataset_method(arg)}
+          end
+        end
+
+        # Sets up a dataset method that returns a filtered dataset.
+        # Sometimes thought of as a scope, and like most dataset methods,
+        # they can be chained.
+        # For example:
+        #
+        #   Topic.subset(:joes, Sequel[:username].like('%joe%'))
+        #   Topic.subset(:popular){num_posts > 100}
+        #   Topic.subset(:recent){created_on > Date.today - 7}
+        #
+        # Allows you to do:
+        #
+        #   Topic.joes.recent.popular
+        #
+        # to get topics with a username that includes joe that
+        # have more than 100 posts and were created less than
+        # 7 days ago.
+        #
+        # Both the args given and the block are passed to <tt>Dataset#where</tt>.
+        #
+        # This method creates dataset methods that do not accept arguments.  To create
+        # dataset methods that accept arguments, you should use define a
+        # method directly inside a #dataset_module block.
+        def subset(*args, &block)
+          dataset_module{subset(*args, &block)}
+        end
+      end
+    end
+  end
+end
+

data/lib/sequel/plugins/defaults_setter.rb

@@ -10,9 +10,37 @@ module Sequel
     #   album = Album.new
     #   album.a # => nil
     #   album.b # => 2
-    #   album = Album.new(:a=>1, :b=>3)
+    #   album = Album.new(a: 1, b: 3)
     #   album.a # => 1
     #   album.b # => 3
+    #
+    # You can manually set default values as well:
+    #
+    #   Album.default_values[:a] = 4
+    #   Album.new.a # => 4
+    #
+    # You can also provide procs to set default values:
+    #
+    #   Album.default_values[:a] = lambda{Date.today}
+    #   Album.new.a # => Date.today
+    #
+    # By default, default values returned are not cached:
+    #
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # However, you can turn on caching of default values:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   Album.new.a.equal?(Album.new.a) # => false
+    #
+    # Note that if the cache is turned on, the cached values are stored in
+    # the values hash:
+    #
+    #   Album.plugin :defaults_setter, cache: true
+    #   album = Album.new
+    #   album.values # => {}
+    #   album.a
+    #   album.values # => {:a => Date.today}
     # 
     # Usage:
     #
@@ -22,27 +50,52 @@ module Sequel
     #   # Make the Album class set defaults 
     #   Album.plugin :defaults_setter
     module DefaultsSetter
-      # Set the default values based on the model schema
-      def self.configure(model)
-        model.send(:set_default_values)
+      # Set the default values based on the model schema. Options:
+      # :cache :: Cache default values returned in the model's values hash.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          set_default_values
+          @cache_default_values = opts[:cache] if opts.has_key?(:cache)
+        end
       end
 
       module ClassMethods
-        # The default values to set in initialize for this model.  A hash with column symbol
+        # The default values to use for this model.  A hash with column symbol
         # keys and default values.  If the default values respond to +call+, it will be called
         # to get the value, otherwise the value will be used directly.  You can manually modify
         # this hash to set specific default values, by default the ones will be parsed from the database.
         attr_reader :default_values
-        
+
         Plugins.after_set_dataset(self, :set_default_values)
 
+        Plugins.inherited_instance_variables(self, :@default_values=>:dup, :@cache_default_values=>nil)
+
+        # Whether default values should be cached in the values hash after being retrieved.
+        def cache_default_values?
+          @cache_default_values
+        end
+        
+        # Freeze default values when freezing model class
+        def freeze
+          @default_values.freeze
+          super
+        end
+
         private
 
         # Parse the cached database schema for this model and set the default values appropriately.
         def set_default_values
           h = {}
-          @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
-          @default_values = h
+          if @db_schema
+            @db_schema.each do |k, v|
+              if v[:callable_default]
+                h[k] = v[:callable_default]
+              elsif !v[:ruby_default].nil?
+                h[k] = convert_default_value(v[:ruby_default])
+              end
+            end
+          end
+          @default_values = h.merge!(@default_values || OPTS)
         end
 
         # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or
@@ -63,8 +116,10 @@ module Sequel
         # Use default value for a new record if values doesn't already contain an entry for it.
         def [](k)
           if new? && !values.has_key?(k)
-            v = model.default_values[k]
-            v.respond_to?(:call) ? v.call : v
+            v = model.default_values.fetch(k){return}
+            v = v.call if v.respond_to?(:call)
+            values[k] = v if model.cache_default_values?
+            v
           else
             super
           end

data/lib/sequel/plugins/delay_add_association.rb

@@ -40,7 +40,7 @@ module Sequel
           if opts.dataset_need_primary_key? && new?
             o = make_add_associated_object(opts, o)
             delay_validate_associated_object(opts, o)
-            send(opts[:name]) << o
+            public_send(opts[:name]) << o
             after_create_hook{super(opts, o, *args)}
             o
           else

data/lib/sequel/plugins/dirty.rb

@@ -41,6 +41,15 @@ module Sequel
     #   artist.column_changes        # => {}
     #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
     #
+    #   artist.column_previously_was(:name)
+    #   # => 'Foo'
+    #   artist.column_previously_changed?(:name)
+    #   # => true
+    #   artist.column_previously_changed?(:name, from: 'Foo', to: 'Bar')
+    #   # => true
+    #   artist.column_previously_changed?(:name, from: 'Foo', to: 'Baz')
+    #   # => false
+    #
     # There is one caveat; when used with a column that also uses the
     # serialization plugin, setting the column back to its original value
     # after changing it is not correctly detected and will leave an entry
@@ -61,6 +70,19 @@ module Sequel
         # that were used in the update statement.
         attr_reader :previous_changes
 
+        # Reset the initial values after saving.
+        def after_save
+          super
+          reset_initial_values
+        end
+
+        # Save the current changes so they are available after updating.  This happens
+        # before after_save resets them.
+        def after_update
+          super
+          @previous_changes = column_changes
+        end
+
         # An array with the initial value and the current value
         # of the column, if the column has been changed.  If the
         # column has not been changed, returns nil.
@@ -92,6 +114,41 @@ module Sequel
           initial_values.has_key?(column)
         end
 
+        # Whether the column was previously changed.
+        # Options:
+        # :from :: If given, the previous initial value of the column must match this
+        # :to :: If given, the previous changed value of the column must match this
+        #
+        #   update(name: 'Current')
+        #   previous_changes                  # => {:name=>['Initial', 'Current']}
+        #   column_previously_changed?(:name) # => true
+        #   column_previously_changed?(:id)   # => false
+        #   column_previously_changed?(:name, from: 'Initial', to: 'Current') # => true
+        #   column_previously_changed?(:name, from: 'Foo', to: 'Current')     # => false
+        def column_previously_changed?(column, opts=OPTS)
+          return false unless (pc = @previous_changes) && (val = pc[column])
+
+          if opts.has_key?(:from)
+            return false unless val[0] == opts[:from]
+          end
+
+          if opts.has_key?(:to)
+            return false unless val[1] == opts[:to]
+          end
+
+          true
+        end
+
+        # The previous value of the column, which is the initial value of
+        # the column before the object was previously saved.
+        #
+        #   initial_value(:name) # => 'Initial'
+        #   update(name: 'Current')
+        #   column_previously_was(:name) # => 'Initial'
+        def column_previously_was(column)
+          (pc = @previous_changes) && (val = pc[column]) && val[0]
+        end
+
         # Freeze internal data structures
         def freeze
           initial_values.freeze
@@ -137,7 +194,7 @@ module Sequel
         #   name.gsub(/i/i, 'o')
         #   column_change(:name) # => ['Initial', 'onotoal']
         def will_change_column(column)
-          changed_columns << column unless changed_columns.include?(column)
+          _add_changed_column(column)
           check_missing_initial_value(column)
 
           value = if initial_values.has_key?(column)
@@ -159,23 +216,10 @@ module Sequel
 
         private
 
-        # Reset the initial values when setting values.
-        def _refresh_set_values(hash)
-          reset_initial_values
-          super
-        end
-
-        # Reset the initial values after saving.
-        def after_save
-          super
-          reset_initial_values
-        end
-
-        # Save the current changes so they are available after updating.  This happens
-        # before after_save resets them.
-        def after_update
+        # Reset initial values when clearing changed columns
+        def _clear_changed_columns(reason)
+          reset_initial_values if reason == :initialize || reason == :refresh
           super
-          @previous_changes = column_changes
         end
 
         # When changing the column value, save the initial column value.  If the column
@@ -186,7 +230,7 @@ module Sequel
             initial = iv[column]
             super
             if value == initial
-              changed_columns.delete(column) unless missing_initial_values.include?(column)
+              _changed_columns.delete(column) unless missing_initial_values.include?(column)
               iv.delete(column)
             end
           else
@@ -214,12 +258,6 @@ module Sequel
           self
         end
 
-        # Reset the initial values when initializing.
-        def initialize_set(h)
-          super
-          reset_initial_values
-        end
-
         # Array holding column symbols that were not present initially.  This is necessary
         # to differentiate between values that were not present and values that were
         # present but equal to nil.

data/lib/sequel/plugins/eager_each.rb

@@ -30,16 +30,16 @@ module Sequel
     module EagerEach 
       module DatasetMethods
         # Don't call #all when attempting to load the columns.
-        def columns
+        def columns!
           if use_eager_all?
-            clone(:all_called=>true).columns
+            clone(:all_called=>true).columns!
           else
             super
           end
         end
 
         # Call #all instead of #each if eager loading,
-        # uless #each is being called by #all.
+        # unless #each is being called by #all.
         def each(&block)
           if use_eager_all?
             all(&block)