occams-record 1.4.0 → 1.9.0

data/lib/occams-record/eager_loaders/builder.rb

@@ -10,6 +10,12 @@ module OccamsRecord
       # Specify an association to be eager-loaded. For maximum memory savings, only SELECT the
       # colums you actually need.
       #
+      # If you pass a block to nest more eager loads, you may call it with one of two forms: with an argument and without:
+      #
+      # If you ommit the block argument, the "self" inside the block will be the eager loader. You can call "eager_load" and "scope" directly.
+      #
+      # If you include the block argument, the "self" inside the block is the same as the self outside the block. The argument will be the eager loader, which you can use to make additional "eager_load" or "scope" calls.
+      #
       # @param assoc [Symbol] name of association
       # @param scope [Proc] a scope to apply to the query (optional). It will be passed an
       # ActiveRecord::Relation on which you may call all the normal query hethods (select, where, etc) as well as any scopes you've defined on the model.
@@ -18,11 +24,12 @@ module OccamsRecord
       # @param as [Symbol] Load the association usign a different attribute name
       # @param from [Symbol] Opposite of `as`. `assoc` is the custom name and `from` is the name of association on the ActiveRecord model.
       # @param optimizer [Symbol] Only used for `through` associations. Options are :none (load all intermediate records) | :select (load all intermediate records but only SELECT the necessary columns)
+      # @param active_record_fallback [Symbol] If passed, missing methods will be forwarded to an ActiveRecord instance. Options are :lazy (allow lazy loading in the AR record) or :strict (require strict loading)
       # @yield a block where you may perform eager loading on *this* association (optional)
       # @return self
       #
-      def eager_load(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select, &builder)
-        @eager_loaders.add(assoc, scope, select: select, use: use, as: as, from: from, optimizer: optimizer, &builder)
+      def eager_load(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select, active_record_fallback: nil, &builder)
+        @eager_loaders.add(assoc, scope, select: select, use: use, as: as, from: from, optimizer: optimizer, active_record_fallback: active_record_fallback, &builder)
         self
       end
 
@@ -39,11 +46,12 @@ module OccamsRecord
       # @param as [Symbol] Load the association usign a different attribute name
       # @param from [Symbol] Opposite of `as`. `assoc` is the custom name and `from` is the name of association on the ActiveRecord model.
       # @param optimizer [Symbol] Only used for `through` associations. Options are :none (load all intermediate records) | :select (load all intermediate records but only SELECT the necessary columns)
+      # @param active_record_fallback [Symbol] If passed, the record(s) will be converted to read-only ActiveRecord objects. Options are :lazy (allow lazy loading) or :strict (enables strict loading)
       # @return [OccamsRecord::EagerLoaders::Base]
       #
-      def nest(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select)
+      def nest(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select, active_record_fallback: nil)
         raise ArgumentError, "OccamsRecord::EagerLoaders::Builder#nest does not accept a block!" if block_given?
-        @eager_loaders.add(assoc, scope, select: select, use: use, as: as, from: from, optimizer: optimizer) ||
+        @eager_loaders.add(assoc, scope, select: select, use: use, as: as, from: from, optimizer: optimizer, active_record_fallback: active_record_fallback) ||
           raise("OccamsRecord::EagerLoaders::Builder#nest may not be called under a polymorphic association")
       end
 

data/lib/occams-record/eager_loaders/context.rb

@@ -14,14 +14,19 @@ module OccamsRecord
       # @return [ActiveRecord::Base]
       attr_reader :model
 
+      # @return [OccamsRecord::EagerLoaders::Tracer]
+      attr_reader :tracer
+
       #
       # Initialize a new eager loading context.
       #
       # @param mode [ActiveRecord::Base] the model that contains the associations that will be referenced.
+      # @param tracer [OccamsRecord::EagerLoaders::Tracer] the eager loader that owns this context (if any)
       # @param polymorphic [Boolean] When true, model is allowed to change, and it's assumed that not every loader is applicable to every model.
       #
-      def initialize(model = nil, polymorphic: false)
+      def initialize(model = nil, tracer: nil, polymorphic: false)
         @model, @polymorphic = model, polymorphic
+        @tracer = tracer || OccamsRecord::EagerLoaders::Tracer.new("root")
         @loaders = []
         @dynamic_loaders = []
       end
@@ -72,10 +77,11 @@ module OccamsRecord
       # @param as [Symbol] Load the association usign a different attribute name
       # @param from [Symbol] Opposite of `as`. `assoc` is the custom name and `from` is the name of association on the ActiveRecord model.
       # @param optimizer [Symbol] Only used for `through` associations. Options are :none (load all intermediate records) | :select (load all intermediate records but only SELECT the necessary columns)
+      # @param active_record_fallback [Symbol] If passed, missing methods will be forwarded to an ActiveRecord instance. Options are :lazy (allow lazy loading in the AR record) or :strict (require strict loading)
       # @yield a block where you may perform eager loading on *this* association (optional)
       # @return [OccamsRecord::EagerLoaders::Base] the new loader. if @model is nil, nil will be returned.
       #
-      def add(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select, &builder)
+      def add(assoc, scope = nil, select: nil, use: nil, as: nil, from: nil, optimizer: :select, active_record_fallback: nil, &builder)
         if from
           real_assoc = from
           custom_name = assoc
@@ -88,11 +94,11 @@ module OccamsRecord
         end
 
         if @model
-          loader = build_loader!(real_assoc, custom_name, scope, select, use, optimizer, builder)
+          loader = build_loader!(real_assoc, custom_name, scope, select, use, optimizer, builder, active_record_fallback)
           @loaders << loader
           loader
         else
-          @dynamic_loaders << [real_assoc, custom_name, scope, select, use, optimizer, builder]
+          @dynamic_loaders << [real_assoc, custom_name, scope, select, use, optimizer, builder, active_record_fallback]
           nil
         end
       end
@@ -111,21 +117,27 @@ module OccamsRecord
         nil
       end
 
+      # Iterate over each loader
+      def each
+        return @loaders.each unless block_given?
+        @loaders.each { |l| yield l }
+      end
+
       private
 
-      def build_loader!(assoc, custom_name, scope, select, use, optimizer, builder)
-        build_loader(assoc, custom_name, scope, select, use, optimizer, builder) ||
-          raise("OccamsRecord: No assocation `:#{assoc}` on `#{@model.name}` or subclasses")
+      def build_loader!(assoc, custom_name, scope, select, use, optimizer, builder, active_record_fallback)
+        build_loader(assoc, custom_name, scope, select, use, optimizer, builder, active_record_fallback) ||
+          raise("OccamsRecord: No association `:#{assoc}` on `#{@model.name}` or subclasses")
       end
 
-      def build_loader(assoc, custom_name, scope, select, use, optimizer, builder)
+      def build_loader(assoc, custom_name, scope, select, use, optimizer, builder, active_record_fallback)
         ref = @model.reflections[assoc.to_s] ||
           @model.subclasses.map(&:reflections).detect { |x| x.has_key? assoc.to_s }&.[](assoc.to_s)
         return nil if ref.nil?
 
         scope ||= ->(q) { q.select select } if select
         loader_class = !!ref.through_reflection ? EagerLoaders::Through : EagerLoaders.fetch!(ref)
-        loader_class.new(ref, scope, use: use, as: custom_name, optimizer: optimizer, &builder)
+        loader_class.new(ref, scope, use: use, as: custom_name, optimizer: optimizer, parent: @tracer, active_record_fallback: active_record_fallback, &builder)
       end
     end
   end

data/lib/occams-record/eager_loaders/eager_loaders.rb

@@ -5,6 +5,7 @@ module OccamsRecord
   module EagerLoaders
     autoload :Builder, 'occams-record/eager_loaders/builder'
     autoload :Context, 'occams-record/eager_loaders/context'
+    autoload :Tracer, 'occams-record/eager_loaders/tracer'
 
     autoload :Base, 'occams-record/eager_loaders/base'
     autoload :BelongsTo, 'occams-record/eager_loaders/belongs_to'

data/lib/occams-record/eager_loaders/habtm.rb

@@ -24,23 +24,21 @@ module OccamsRecord
       # @param join_rows [Array<Array<String>>] raw join'd ids from the db
       #
       def merge!(assoc_rows, rows, join_rows)
-        joins_by_id = join_rows.reduce({}) { |a, join|
+        joins_by_id = join_rows.each_with_object({}) { |join, acc|
           id = join[0].to_s
-          a[id] ||= []
-          a[id] << join[1].to_s
-          a
+          acc[id] ||= []
+          acc[id] << join[1].to_s
         }
 
         assoc_order_cache = {} # maintains the original order of assoc_rows
-        assoc_rows_by_id = assoc_rows.each_with_index.reduce({}) { |a, (row, idx)|
+        assoc_rows_by_id = assoc_rows.each_with_index.each_with_object({}) { |(row, idx), acc|
           begin
             id = row.send(@ref.association_primary_key).to_s
           rescue NoMethodError => e
             raise MissingColumnError.new(row, e.name)
           end
           assoc_order_cache[id] = idx
-          a[id] = row
-          a
+          acc[id] = row
         }
 
         assign = "#{name}="

data/lib/occams-record/eager_loaders/has_one.rb

@@ -20,7 +20,6 @@ module OccamsRecord
             raise MissingColumnError.new(row, e.name)
           end
         }.compact.uniq
-        ids.sort! if $occams_record_test
 
         q = base_scope.where(@ref.foreign_key => ids)
         q.where!(@ref.type => rows[0].class&.model_name) if @ref.options[:as]

data/lib/occams-record/eager_loaders/polymorphic_belongs_to.rb

@@ -7,6 +7,12 @@ module OccamsRecord
       # @return [String] association name
       attr_reader :name
 
+      # @return [OccamsRecord::EagerLoaders::Tracer | nil] a reference to this eager loader and its parent (if any)
+      attr_reader :tracer
+
+      # @return [OccamsRecord::EagerLoaders::Context]
+      attr_reader :eager_loaders
+
       #
       # @param ref [ActiveRecord::Association] the ActiveRecord association
       # @param scope [Proc] a scope to apply to the query (optional). It will be passed an
@@ -14,15 +20,39 @@ module OccamsRecord
       # @param use [Array<Module>] optional Module to include in the result class (single or array)
       # @param as [Symbol] Load the association usign a different attribute name
       # @param optimizer [Symbol] Only used for `through` associations. A no op here.
+      # @param parent [OccamsRecord::EagerLoaders::Tracer] the eager loader this one is nested under (if any)
+      # @param active_record_fallback [Symbol] If passed, missing methods will be forwarded to an ActiveRecord instance. Options are :lazy (allow lazy loading in the AR record) or :strict (require strict loading)
       # @yield perform eager loading on *this* association (optional)
       #
-      def initialize(ref, scope = nil, use: nil, as: nil, optimizer: nil, &builder)
-        @ref, @scope, @use = ref, scope, use
+      def initialize(ref, scope = nil, use: nil, as: nil, optimizer: nil, parent: nil, active_record_fallback: nil, &builder)
+        @ref, @scopes, @use = ref, Array(scope), use
         @name = (as || ref.name).to_s
         @foreign_type = @ref.foreign_type.to_sym
         @foreign_key = @ref.foreign_key.to_sym
-        @eager_loaders = EagerLoaders::Context.new(nil, polymorphic: true)
-        instance_exec(&builder) if builder
+        @tracer = Tracer.new(name, parent)
+        @eager_loaders = EagerLoaders::Context.new(nil, tracer: @tracer, polymorphic: true)
+        @active_record_fallback = active_record_fallback
+        if builder
+          if builder.arity > 0
+            builder.call(self)
+          else
+            instance_exec(&builder)
+          end
+        end
+      end
+
+      #
+      # An alternative to passing a "scope" lambda to the constructor. Your block is passed the query
+      # so you can call select, where, order, etc on it.
+      #
+      # If you call scope multiple times, the results will be additive.
+      #
+      # @yield [ActiveRecord::Relation] a relation to modify with select, where, order, etc
+      # @return self
+      #
+      def scope(&scope)
+        @scopes << scope if scope
+        self
       end
 
       #
@@ -35,7 +65,7 @@ module OccamsRecord
         query(rows) { |scope|
           eager_loaders = @eager_loaders.dup
           eager_loaders.model = scope.klass
-          assoc_rows = Query.new(scope, use: @use, eager_loaders: eager_loaders, query_logger: query_logger, measurements: measurements).run
+          assoc_rows = Query.new(scope, use: @use, eager_loaders: eager_loaders, query_logger: query_logger, measurements: measurements, active_record_fallback: @active_record_fallback).run
           merge! assoc_rows, rows
         }
         nil
@@ -55,7 +85,6 @@ module OccamsRecord
           next if type.nil? or type == ""
           model = type.constantize
           ids = rows_of_type.map(&@foreign_key).uniq
-          ids.sort! if $occams_record_test
           q = base_scope(model).where(@ref.active_record_primary_key => ids)
           yield q if ids.any?
         end
@@ -83,7 +112,7 @@ module OccamsRecord
       def base_scope(model)
         q = model.all
         q = q.instance_exec(&@ref.scope) if @ref.scope
-        q = @scope.(q) if @scope
+        q = @scopes.reduce(q) { |acc, scope| scope.(acc) }
         q
       end
     end

data/lib/occams-record/eager_loaders/through.rb

@@ -9,7 +9,7 @@ module OccamsRecord
       #
       # See documentation for OccamsRecord::EagerLoaders::Base.
       #
-      def initialize(ref, scope = nil, use: nil, as: nil, optimizer: :select, &builder)
+      def initialize(ref, scope = nil, use: nil, as: nil, optimizer: :select, parent: nil, active_record_fallback: nil, &builder)
         super
 
         unless @ref.macro == :has_one or @ref.macro == :has_many
@@ -20,7 +20,7 @@ module OccamsRecord
           raise ArgumentError, "#{@ref.active_record.name}##{@ref.name} cannot be eager loaded because these `through` associations are polymorphic: #{names.join ', '}"
         end
         unless @optimizer == :none or @optimizer == :select
-          raise ArgumentError, "Unrecognized optimizer '#{@optimizer}'"
+          raise ArgumentError, "Unrecognized optimizer '#{@optimizer}' (valid options are :none, :select)"
         end
 
         chain = @ref.chain.reverse
@@ -31,7 +31,6 @@ module OccamsRecord
         @loader = build_loader
       end
 
-      # TODO make not hacky
       def through_name
         @loader.name
       end
@@ -47,6 +46,7 @@ module OccamsRecord
 
       private
 
+      # starting at the top of the chain, recurse and return the leaf node(s)
       def reduce(node, depth = 0)
         link = @chain[depth]
         case link&.macro
@@ -69,33 +69,48 @@ module OccamsRecord
         end
       end
 
+      # build all the nested eager loaders
       def build_loader
         head = @chain[0]
         links = @chain[1..-2]
         tail = @chain[-1]
 
-        outer_loader = EagerLoaders.fetch!(head.ref).new(head.ref, optimized_select(head))
+        outer_loader = EagerLoaders.fetch!(head.ref).new(head.ref, optimized_scope(head), parent: tracer.parent)
+        outer_loader.tracer.through = true
 
-        links.
+        inner_loader = links.
           reduce(outer_loader) { |loader, link|
-            loader.nest(link.ref.source_reflection.name, optimized_select(link))
+            nested_loader = loader.nest(link.ref.source_reflection.name, optimized_scope(link))
+            nested_loader.tracer.through = true
+            nested_loader
           }.
-          nest(tail.ref.source_reflection.name, @scope, use: @use, as: @as)
+          nest(tail.ref.source_reflection.name, @scopes, use: @use, as: @as, active_record_fallback: @active_record_fallback)
 
+        @eager_loaders.each { |loader| inner_loader.eager_loaders << loader }
+        inner_loader.tracer.name = tracer.name
         outer_loader
       end
 
-      def optimized_select(link)
-        return nil unless @optimizer == :select
+      def optimized_scope(link)
+        case @optimizer
+        when :select
+          optimized_select(link)
+        when :none
+          nil
+        end
+      end
 
-        cols = case link.macro
-               when :belongs_to
-                 [link.ref.association_primary_key]
-               when :has_one, :has_many
-                 [link.ref.association_primary_key, link.ref.foreign_key]
-               else
-                 raise "Unsupported through chain link type '#{link.macro}'"
-               end
+      # only select the ids/foreign keys required to link the parent/child records
+      def optimized_select(link)
+        cols =
+          case link.macro
+          when :belongs_to
+            [link.ref.association_primary_key]
+          when :has_one, :has_many
+            [link.ref.association_primary_key, link.ref.foreign_key]
+          else
+            raise "Unsupported through chain link type '#{link.macro}'"
+          end
 
         case link.next_ref.source_reflection.macro
         when :belongs_to

data/lib/occams-record/eager_loaders/tracer.rb

@@ -0,0 +1,16 @@
+module OccamsRecord
+  module EagerLoaders
+    # A low-memory way to trace the path of eager loads from any point back to the root query
+    Tracer = Struct.new(:name, :parent, :through) do
+      def to_s
+        lookup.join(".")
+      end
+
+      def lookup(trace = self)
+        return [] if trace.nil?
+        name = trace.through ? "through(#{trace.name})" : trace.name
+        lookup(trace.parent) << name
+      end
+    end
+  end
+end

data/lib/occams-record/errors.rb

@@ -13,6 +13,7 @@ module OccamsRecord
     def initialize(record, name)
       @record, @name = record, name
       @model_name = record.class.model_name
+      @load_trace = record.class.eager_loader_trace
     end
 
     # @return [String]
@@ -25,7 +26,8 @@ module OccamsRecord
   class MissingColumnError < MissingDataError
     # @return [String]
     def message
-      "Column '#{name}' is unavailable on #{model_name} because it was not included in the SELECT statement!"
+      loads = @load_trace.to_s
+      "Column '#{name}' is unavailable on #{model_name} because it was not included in the SELECT statement! Occams Record trace: #{loads}"
     end
   end
 
@@ -33,7 +35,8 @@ module OccamsRecord
   class MissingEagerLoadError < MissingDataError
     # @return [String]
     def message
-      "Association '#{name}' is unavailable on #{model_name} because it was not eager loaded!"
+      loads = @load_trace.to_s
+      "Association '#{name}' is unavailable on #{model_name} because it was not eager loaded! Occams Record trace: #{loads}"
     end
   end
 
@@ -45,6 +48,7 @@ module OccamsRecord
     attr_reader :attrs
 
     # @param model_name [String]
+    #
     # @param attrs [Hash]
     def initialize(model_name, attrs)
       @model_name, @attrs = model_name, attrs

data/lib/occams-record/merge.rb

@@ -35,14 +35,13 @@ module OccamsRecord
       # Optimized for merges where there's a single mapping key pair (which is the vast majority)
       if mapping.size == 1
         target_attr, assoc_attr = target_attrs[0], assoc_attrs[0]
-        assoc_rows_by_ids = assoc_rows.reduce({}) { |a, assoc_row|
+        assoc_rows_by_ids = assoc_rows.each_with_object({}) { |assoc_row, acc|
           begin
             id = assoc_row.send assoc_attr
           rescue NoMethodError => e
             raise MissingColumnError.new(assoc_row, e.name)
           end
-          a[id] ||= assoc_row
-          a
+          acc[id] ||= assoc_row
         }
 
         target_rows.each do |row|
@@ -56,14 +55,13 @@ module OccamsRecord
 
       # Slower but works with any number of mapping key pairs
       else
-        assoc_rows_by_ids = assoc_rows.reduce({}) { |a, assoc_row|
+        assoc_rows_by_ids = assoc_rows.each_with_object({}) { |assoc_row, acc|
           begin
             ids = assoc_attrs.map { |attr| assoc_row.send attr }
           rescue NoMethodError => e
             raise MissingColumnError.new(assoc_row, e.name)
           end
-          a[ids] ||= assoc_row
-          a
+          acc[ids] ||= assoc_row
         }
 
         target_rows.each do |row|

data/lib/occams-record/pluck.rb

@@ -0,0 +1,38 @@
+module OccamsRecord
+  module Pluck
+    private
+
+    def pluck_results(results, model: nil)
+      casters = TypeCaster.generate(results.columns, results.column_types, model: model)
+      if results[0]&.size == 1
+        pluck_results_single(results, casters)
+      else
+        pluck_results_multi(results, casters)
+      end
+    end
+
+    # returns an array of values
+    def pluck_results_single(results, casters)
+      col = results.columns[0]
+      caster = casters[col]
+      if caster
+        results.map { |row|
+          val = row[col]
+          caster.(val)
+        }
+      else
+        results.map { |row| row[col] }
+      end
+    end
+
+    # returns an array of arrays
+    def pluck_results_multi(results, casters)
+      results.map { |row|
+        row.map { |col, val|
+          caster = casters[col]
+          caster ? caster.(val) : val
+        }
+      }
+    end
+  end
+end

data/lib/occams-record/query.rb

@@ -18,10 +18,11 @@ module OccamsRecord
   # @param scope [ActiveRecord::Relation]
   # @param use [Module] optional Module to include in the result class
   # @param query_logger [Array] (optional) an array into which all queries will be inserted for logging/debug purposes
+  # @param active_record_fallback [Symbol] If passed, missing methods will be forwarded to an ActiveRecord instance. Options are :lazy (allow lazy loading in the AR record) or :strict (require strict loading)
   # @return [OccamsRecord::Query]
   #
-  def self.query(scope, use: nil, query_logger: nil)
-    Query.new(scope, use: use, query_logger: query_logger)
+  def self.query(scope, use: nil, active_record_fallback: nil, query_logger: nil)
+    Query.new(scope, use: use, query_logger: query_logger, active_record_fallback: active_record_fallback)
   end
 
   #
@@ -35,6 +36,7 @@ module OccamsRecord
     attr_reader :scope
 
     include OccamsRecord::Batches::CursorHelpers
+    include OccamsRecord::Pluck
     include EagerLoaders::Builder
     include Enumerable
     include Measureable
@@ -47,13 +49,15 @@ module OccamsRecord
     # @param query_logger [Array] (optional) an array into which all queries will be inserted for logging/debug purposes
     # @param eager_loaders [OccamsRecord::EagerLoaders::Context]
     # @param measurements [Array]
+    # @param active_record_fallback [Symbol] If passed, missing methods will be forwarded to an ActiveRecord instance. Options are :lazy (allow lazy loading in the AR record) or :strict (require strict loading)
     #
-    def initialize(scope, use: nil, eager_loaders: nil, query_logger: nil, measurements: nil)
+    def initialize(scope, use: nil, eager_loaders: nil, query_logger: nil, measurements: nil, active_record_fallback: nil)
       @model = scope.klass
       @scope = scope
       @eager_loaders = eager_loaders || EagerLoaders::Context.new(@model)
       @use = use
       @query_logger, @measurements = query_logger, measurements
+      @active_record_fallback = active_record_fallback
     end
 
     #
@@ -92,16 +96,19 @@ module OccamsRecord
     #
     def run
       sql = block_given? ? yield(scope).to_sql : scope.to_sql
-      @query_logger << sql if @query_logger
-      result = if measure?
-                 record_start_time!
-                 measure!(model.table_name, sql) {
-                   model.connection.exec_query sql
-                 }
-               else
-                 model.connection.exec_query sql
-               end
-      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.names, model: model, modules: @use)
+      return [] if sql.blank? # return early in case ActiveRecord::QueryMethods#none was used
+
+      @query_logger << "#{@eager_loaders.tracer}: #{sql}" if @query_logger
+      result =
+        if measure?
+          record_start_time!
+          measure!(model.table_name, sql) {
+            model.connection.exec_query sql
+          }
+        else
+          model.connection.exec_query sql
+        end
+      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.names, model: model, modules: @use, tracer: @eager_loaders.tracer, active_record_fallback: @active_record_fallback)
       rows = result.rows.map { |row| row_class.new row }
       @eager_loaders.run!(rows, query_logger: @query_logger, measurements: @measurements)
       yield_measurements!
@@ -222,5 +229,30 @@ module OccamsRecord
         use: @use, query_logger: @query_logger, eager_loaders: @eager_loaders,
       )
     end
+
+    #
+    # Returns the specified column(s) as an array of values.
+    #
+    # If more than one column is given, the result will be an array of arrays.
+    #
+    # @param cols [Array] one or more column names as Symbols or Strings. Also accepts SQL functions, e.g. "LENGTH(name)".
+    # @return [Array]
+    #
+    def pluck(*cols)
+      sql = (block_given? ? yield(scope).to_sql : scope).unscope(:select).select(*cols).to_sql
+      return [] if sql.blank? # return early in case ActiveRecord::QueryMethods#none was used
+
+      @query_logger << "#{@eager_loaders.tracer}: #{sql}" if @query_logger
+      result =
+        if measure?
+          record_start_time!
+          measure!(model.table_name, sql) {
+            model.connection.exec_query sql
+          }
+        else
+          model.connection.exec_query sql
+        end
+      pluck_results(result, model: @model)
+    end
   end
 end