occams-record 1.6.0 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a367407e2af3e4110327d26438fcb2a590b7fbd34e6b60dd4bd9396665c495fe
-  data.tar.gz: 8cf6fb913ac787126a80fe38baff3a56940cea8afc80e1b05e3c864ae8368e11
+  metadata.gz: 6a233847b8c1a9de8c77e8c5e1d12f70ea7c8b9efa498208491a17ff09a6f217
+  data.tar.gz: f87fbaf43703cd29b60b94a480ad903d00cad2b9b3bd9bfb4a77b7748f68aa81
 SHA512:
-  metadata.gz: 2bc45d11bc974e5a5ec6b2b9ffab8e3f069048ee8335122ad81a8b49cc852fa4bdb27116865000e4b70e4f6d617b3f870861288e00a43b273e3ec14d0dfdb6b6
-  data.tar.gz: af1dac7260e93ed3778ff022c3d6113819528e37d77c275b9cada6cd5e731593bbe9e4f24ae283ed572a4876672126df4cb002ab8f9c863e3de4943f95acdbc2
+  metadata.gz: 21115e90f5f455eaf33d5c0596d6276957905fb14932583fcdfacdb1a44f7afeaee029458de903fa58c2801e7504643c6c6e4a530822409ff93da6954648a06e
+  data.tar.gz: a38eba237379a4a0b55d027746a8796f9aa9904e60bb1ba6acd6fd46348fc84e0aef17fc6de482d5b32d6677c09b2ea53602b000bf6da9a60d5bd2dec0e72b3f

data/README.md

@@ -146,7 +146,7 @@ OccamsRecord
     order.line_items.each { |line_item|
       puts line_item.product.name
       puts line_item.product.category.name
-      OccamsRecord::MissingEagerLoadError: Association 'category' is unavailable on Product because it was not eager loaded!
+      OccamsRecord::MissingEagerLoadError: Association 'category' is unavailable on Product because it was not eager loaded! Found at root.line_items.product
     }
   }
 ```
@@ -303,7 +303,11 @@ The SQL string and binds should be familiar. `%{ids}` will be provided for you -
 
 ## Injecting instance methods
 
-Occams Records results are just plain rows; there are no methods from your Rails models. (Separating your persistence layer from your domain is good thing!) But sometimes you need a few methods. Occams Record allows you to specify modules to be included in your results.
+Occams Records results are just plain rows; there are no methods from your Rails models. (Separating your persistence layer from your domain is good thing!) But sometimes you need a few methods. Occams Record provides two ways of accomplishing this.
+
+### Include custom modules
+
+You may also specify one or more modules to be included in your results:
 
 ```ruby
 module MyOrderMethods
@@ -326,6 +330,23 @@ orders = OccamsRecord
   .run
 ```
 
+### ActiveRecord method fallback
+
+This is an ugly hack of last resort if you can't easily extract a method from your model into a shared module. Plugins, like `carrierwave`, are a good example. When you call a method that doesn't exist on an Occams Record result, it will initialize an ActiveRecord object and forward the method call to it.
+
+The `active_record_fallback` option must be passed either `:lazy` or `:strict` (recommended). `:strict` enables ActiveRecord's strict loading option, helping you avoid N+1 queries. :lazy allows them. Note that `:strict` is only available for ActiveRecord 6.1 and later.
+
+The following will forward any nonexistent methods for `Order` and `Product` records:
+
+```ruby
+orders = OccamsRecord
+  .query(Order.all, active_record_fallback: :strict)
+  .eager_load(:line_items) {
+    eager_load(:product, active_record_fallback: :strict)
+  }
+  .run
+```
+
 ---
 
 # Unsupported features

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

@@ -11,6 +11,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
+
       #
       # Initialize a new add hoc association.
       #
@@ -20,12 +26,14 @@ module OccamsRecord
       # @param binds [Hash] any additional binds for your query.
       # @param model [ActiveRecord::Base] optional - ActiveRecord model that represents what you're loading. required when using Sqlite.
       # @param use [Array<Module>] optional - Ruby modules to include in the result objects (single or array)
+      # @param parent [OccamsRecord::EagerLoaders::Tracer] the eager loader this one is nested under (if any)
       # @yield eager load associations nested under this one
       #
-      def initialize(name, mapping, sql, binds: {}, model: nil, use: nil, &builder)
+      def initialize(name, mapping, sql, binds: {}, model: nil, use: nil, parent: nil, &builder)
         @name, @mapping = name.to_s, mapping
         @sql, @binds, @use, @model = sql, binds, use, model
-        @eager_loaders = EagerLoaders::Context.new(@model)
+        @tracer = Tracer.new(name, parent)
+        @eager_loaders = EagerLoaders::Context.new(@model, tracer: @tracer)
         if builder
           if builder.arity > 0
             builder.call(self)

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

@@ -9,6 +9,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
@@ -16,13 +22,17 @@ 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. Options are :none (load all intermediate records) | :select (load all intermediate records but only SELECT the necessary columns)
+      # @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: :select, &builder)
+      def initialize(ref, scope = nil, use: nil, as: nil, optimizer: :select, parent: nil, active_record_fallback: nil, &builder)
         @ref, @scopes, @use, @as = ref, Array(scope), use, as
         @model = ref.klass
         @name = (as || ref.name).to_s
-        @eager_loaders = EagerLoaders::Context.new(@model)
+        @tracer = Tracer.new(name, parent)
+        @eager_loaders = EagerLoaders::Context.new(@model, tracer: @tracer)
+        @active_record_fallback = active_record_fallback
         @optimizer = optimizer
         if builder
           if builder.arity > 0
@@ -55,7 +65,7 @@ module OccamsRecord
       #
       def run(rows, query_logger: nil, measurements: nil)
         query(rows) { |*args|
-          assoc_rows = args[0] ? Query.new(args[0], use: @use, eager_loaders: @eager_loaders, query_logger: query_logger, measurements: measurements).run : []
+          assoc_rows = args[0] ? Query.new(args[0], use: @use, eager_loaders: @eager_loaders, query_logger: query_logger, measurements: measurements, active_record_fallback: @active_record_fallback).run : []
           merge! assoc_rows, rows, *args[1..-1]
         }
         nil

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

@@ -24,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
 
@@ -45,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) ||
+      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/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,14 +20,18 @@ 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)
+      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)
+        @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)
@@ -55,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

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
@@ -74,14 +74,19 @@ module OccamsRecord
         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_select(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_select(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, @scope, 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
 

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/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
 
   #
@@ -47,13 +48,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,7 +95,7 @@ module OccamsRecord
     #
     def run
       sql = block_given? ? yield(scope).to_sql : scope.to_sql
-      @query_logger << sql if @query_logger
+      @query_logger << "#{@eager_loaders.tracer}: #{sql}" if @query_logger
       result = if measure?
                  record_start_time!
                  measure!(model.table_name, sql) {
@@ -101,7 +104,7 @@ module OccamsRecord
                else
                  model.connection.exec_query sql
                end
-      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.names, model: model, modules: @use)
+      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!

data/lib/occams-record/raw_query.rb

@@ -117,7 +117,7 @@ module OccamsRecord
                else
                  conn.exec_query _escaped_sql
                end
-      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.names, model: @eager_loaders.model, modules: @use)
+      row_class = OccamsRecord::Results.klass(result.columns, result.column_types, @eager_loaders.names, model: @eager_loaders.model, modules: @use, tracer: @eager_loaders.tracer)
       rows = result.rows.map { |row| row_class.new row }
       @eager_loaders.run!(rows, query_logger: @query_logger, measurements: @measurements)
       yield_measurements!

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

@@ -17,9 +17,14 @@ module OccamsRecord
     # @param association_names [Array<String>] names of associations that will be eager loaded into the results.
     # @param model [ActiveRecord::Base] the AR model representing the table (it holds column & type info).
     # @param modules [Array<Module>] (optional)
+    # @param tracer [OccamsRecord::EagerLoaders::Tracer] the eager loaded that loaded this class of records
+    # @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::Results::Row] a class customized for this result set
     #
-    def self.klass(column_names, column_types, association_names = [], model: nil, modules: nil)
+    def self.klass(column_names, column_types, association_names = [], model: nil, modules: nil, tracer: nil, active_record_fallback: nil)
+      raise ArgumentError, "Invalid active_record_fallback option :#{active_record_fallback}. Valid options are :lazy, :strict" if active_record_fallback and !%i(lazy strict).include?(active_record_fallback)
+      raise ArgumentError, "Option active_record_fallback is not allowed when no model is present" if active_record_fallback and model.nil?
+
       Class.new(Results::Row) do
         Array(modules).each { |mod| prepend mod } if modules
 
@@ -28,6 +33,8 @@ module OccamsRecord
         self._model = model
         self.model_name = model ? model.name : nil
         self.table_name = model ? model.table_name : nil
+        self.eager_loader_trace = tracer
+        self.active_record_fallback = active_record_fallback
         self.primary_key = if model&.primary_key and (pkey = model.primary_key.to_s) and columns.include?(pkey)
                              pkey
                            end

data/lib/occams-record/results/row.rb

@@ -19,6 +19,10 @@ module OccamsRecord
         attr_accessor :table_name
         # Name of primary key column (nil if column wasn't in the SELECT)
         attr_accessor :primary_key
+        # A trace of how this record was loaded (for debugging)
+        attr_accessor :eager_loader_trace
+        # If present, missing methods will be forwarded to the ActiveRecord model. :lazy allows lazy loading in AR, :strict doesn't
+        attr_accessor :active_record_fallback
       end
       self.columns = []
       self.associations = []
@@ -110,19 +114,24 @@ module OccamsRecord
       IDS_SUFFIX = /_ids$/
       def method_missing(name, *args, &block)
         model = self.class._model
-        return super if args.any? or !block.nil? or model.nil?
+        ex = NoMethodError.new("Undefined method `#{name}' for #{self.inspect}. Occams Record trace: #{self.class.eager_loader_trace}", name, args)
+        raise ex if model.nil?
 
         name_str = name.to_s
         assoc = name_str.sub(IDS_SUFFIX, "").pluralize
-        if name_str =~ IDS_SUFFIX and can_define_ids_reader? assoc
+        no_args = args.empty? && block.nil?
+
+        if no_args and name_str =~ IDS_SUFFIX and can_define_ids_reader? assoc
           define_ids_reader! assoc
           send name
-        elsif model.reflections.has_key? name_str
+        elsif no_args and model.reflections.has_key? name_str
           raise MissingEagerLoadError.new(self, name)
-        elsif model.columns_hash.has_key? name_str
+        elsif no_args and model.columns_hash.has_key? name_str
           raise MissingColumnError.new(self, name)
+        elsif self.class.active_record_fallback
+          active_record_fallback(name, *args, &block)
         else
-          super
+          raise ex
         end
       end
 
@@ -141,6 +150,15 @@ module OccamsRecord
 
       private
 
+      def active_record_fallback(name, *args, &block)
+        @active_record_fallback ||= Ugly::active_record(self.class._model, self).tap { |record|
+          record.strict_loading! if self.class.active_record_fallback == :strict
+        }
+        @active_record_fallback.send(name, *args, &block)
+      rescue NoMethodError => e
+        raise NoMethodError.new("#{e.message}. Occams Record trace: #{self.class.eager_loader_trace}.active_record_fallback(#{self.class._model.name})", name, args)
+      end
+
       def can_define_ids_reader?(assoc)
         model = self.class._model
         self.class.associations.include?(assoc) &&

data/lib/occams-record/version.rb

@@ -3,5 +3,5 @@
 #
 module OccamsRecord
   # @private
-  VERSION = "1.6.0".freeze
+  VERSION = "1.6.2".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: occams-record
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.2
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-14 00:00:00.000000000 Z
+date: 2023-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -70,6 +70,7 @@ files:
 - lib/occams-record/eager_loaders/has_one.rb
 - lib/occams-record/eager_loaders/polymorphic_belongs_to.rb
 - lib/occams-record/eager_loaders/through.rb
+- lib/occams-record/eager_loaders/tracer.rb
 - lib/occams-record/errors.rb
 - lib/occams-record/measureable.rb
 - lib/occams-record/merge.rb