occams-record 1.4.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1dc718c0f99f5ad039974f8db3bd1c5304e41a3b3275d26dd1d86235c7790fe
-  data.tar.gz: 8af374148ca1f1c8342b7eb8fdb30031d6c31a1d923a6e7cab55b96712ed2602
+  metadata.gz: e26a6e33886dfdb5cb2d3000e32c9de7e04bb7b26cc4434c5df7f1deb094ac58
+  data.tar.gz: 9cc37f3ab8beeef6e55d5adae2e1f76268acad3381b789f70c896a515abe8cfa
 SHA512:
-  metadata.gz: 54b539bc70b1fc92c087fbc91f7edbaa1eb4dabacfda80ca0afa4ccd4ac53e832d431f3c95e35785cfa7bd7075879c655ae54019c3f341255b4411929b5ae615
-  data.tar.gz: c1c9aed1007bcfeb0e577d08af6f86fa340e375fede08af03bd18fbc2538cfcbd4838fc5bd07c672fca6e02ca3c0ec9e8d442b3e3275deff58215dfba873df7a
+  metadata.gz: a8236d746e52a2890dfb83e838db153150c249ff0b5fb53a1bc949d386258b5047dc93e63a40d747e0f584ffbcaf3d069122962c23a2fc3691a4e162044927af
+  data.tar.gz: 1883cb2f7d7817561837b911828b56b540b5dff7845a943340c489786b73be9b3c24270ec2d32a5e7b9ecdb324a21f346948f183e13439e9339424ee9b593ad9

data/README.md

@@ -1,7 +1,9 @@
-# Occams Record [![Build Status](https://travis-ci.org/jhollinger/occams-record.svg?branch=master)](https://travis-ci.org/jhollinger/occams-record)
+# Occams Record
 
 > Do not multiply entities beyond necessity. -- Occam's Razor
 
+Full documentation is available at [rubydoc.info/gems/occams-record](http://www.rubydoc.info/gems/occams-record).
+
 OccamsRecord is a high-efficiency, advanced query library for use alongside ActiveRecord. It is **not** an ORM or an ActiveRecord replacement. OccamsRecord can breathe fresh life into your ActiveRecord app by giving it two things:
 
 ### 1) Huge performance gains
@@ -9,107 +11,33 @@ OccamsRecord is a high-efficiency, advanced query library for use alongside Acti
 * 3x-5x faster than ActiveRecord queries, *minimum*.
 * Uses 1/3 the memory of ActiveRecord query results.
 * Eliminates the N+1 query problem. (This often exceeds the baseline 3x-5x gain.)
-* Support for cursors (Postgres only, new in v1.4.0-beta1)
 
 ### 2) Supercharged querying & eager loading
 
-Continue using ActiveRecord's query builder, but let Occams take over running them, eager loading, and raw SQL calls. None of the examples below are possible with ActiveRecord, but OccamsRecord makes them trivial. (More complete examples are shown later, but these should whet your appetite.)
-
-**Customize the SQL used to eager load associations**
-
-```ruby
-OccamsRecord
-  .query(User.active)
-  .eager_load(:orders, ->(q) { q.where("created_at >= ?", date).order("created_at DESC") })
-```
-
-**Use `ORDER BY` with `find_each`/`find_in_batches`**
-
-```ruby
-OccamsRecord
-  .query(Order.order("created_at DESC"))
-  .find_each { |order|
-    ...
-  }
-```
-
-**Use cursors**
-
-```ruby
-OccamsRecord
-  .query(Order.order("created_at DESC"))
-  .find_each_with_cursor { |order|
-    ...
-  }
-```
-
-**Use `find_each`/`find_in_batches` with raw SQL**
-
-```ruby
-OccamsRecord
-  .sql("
-    SELECT * FROM orders
-    WHERE created_at >= %{date}
-    LIMIT %{batch_limit}
-    OFFSET %{batch_offset}",
-    {date: 10.years.ago}
-  )
-  .find_each { |order|
-    ...
-  }
-```
-
-**Eager load associations when you're writing raw SQL**
-
-```ruby
-OccamsRecord
-  .sql("
-    SELECT * FROM users
-    LEFT OUTER JOIN ...
-  ")
-  .model(User)
-  .eager_load(:orders)
-```
-
-**Eager load "ad hoc associations" using raw SQL**
-
-Relationships are complicated, and sometimes they can't be expressed in ActiveRecord models. Define your relationship on the fly!
-(Don't worry, there's a full explanation later on.)
-
-```ruby
-OccamsRecord
-  .query(User.all)
-  .eager_load_many(:orders, {:id => :user_id}, "
-    SELECT user_id, orders.*
-    FROM orders INNER JOIN ...
-    WHERE user_id IN (%{ids})
-  ")
-```
+* Customize the SQL used to eager load associations (order them, apply filters, etc)
+* Use cursors (Postgres only)
+* Use `ORDER BY` with `find_each`/`find_in_batches`
+* Use `find_each`/`find_in_batches` with raw SQL
+* Eager load associations off of raw SQL queries
+* Use `pluck` with raw SQL queries
 
+### How does OccamsRecord do all this?
 [Look over the speed and memory measurements yourself!](https://github.com/jhollinger/occams-record/wiki/Measurements) OccamsRecord achieves all of this by making some **very specific trade-offs:**
 
 * OccamsRecord results are *read-only*.
 * OccamsRecord results are *purely database rows* - they don't have any instance methods from your Rails models.
-* You *must eager load* each assocation you intend to use. If you forget one, an exception will be raised.
+* You *must eager load* each assocation you intend to use. If you try to use one you didn't eager load, an exception will be raised.
 
----
+# Overview
 
-# Installation
+Full documentation is available at [rubydoc.info/gems/occams-record](http://www.rubydoc.info/gems/occams-record). Code lives at at [github.com/jhollinger/occams-record](https://github.com/jhollinger/occams-record). Contributions welcome!
 
-Simply add it to your `Gemfile`:
+Simply add `occams-record` to your `Gemfile`:
 
 ```ruby
 gem 'occams-record'
 ```
 
----
-
-# Overview
-
-Full documentation is available at [rubydoc.info/gems/occams-record](http://www.rubydoc.info/gems/occams-record).
-
-Code lives at at [github.com/jhollinger/occams-record](https://github.com/jhollinger/occams-record). Contributions welcome!
-
 Build your queries like normal, using ActiveRecord's excellent query builder. Then pass them off to Occams Record.
 
 ```ruby
@@ -135,16 +63,16 @@ Eager loading is similiar to ActiveRecord's `preload`: each association is loade
 OccamsRecord
   .query(q)
   .eager_load(:customer)
-  .eager_load(:line_items) {
-    eager_load(:product)
-    eager_load(:something_else)
+  .eager_load(:line_items) { |l|
+    l.eager_load(:product)
+    l.eager_load(:something_else)
   }
   .find_each { |order|
     puts order.customer.name
     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
     }
   }
 ```
@@ -158,11 +86,14 @@ orders = OccamsRecord
   .query(q)
   # Only SELECT the columns you need. Your DBA will thank you.
   .eager_load(:customer, select: "id, name")
-  
-  # A Proc can use ActiveRecord's query builder
-  .eager_load(:line_items, ->(q) { q.active.order("created_at") }) {
-    eager_load(:product)
-    eager_load(:something_else)
+
+  # Or use 'scope' to access the full power of ActiveRecord's query builder.
+  # Here, only 'active' line items will be returned, and in a specific order.
+  .eager_load(:line_items) { |l|
+    l.scope { |q| q.active.order("created_at") }
+
+    l.eager_load(:product)
+    l.eager_load(:something_else)
   }
   .run
 ```
@@ -199,6 +130,18 @@ orders = OccamsRecord
 
 ActiveRecord has raw SQL escape hatches like `find_by_sql` and `exec_query`, but they give up critical features like eager loading and `find_each`/`find_in_batches`. Occams Record's escape hatches don't make you give up anything.
 
+**Query params**
+
+```ruby
+# Supported in all versions of OccamsRecord
+OccamsRecord.sql("SELECT * FROM orders WHERE user_id = %{user_id}", {user_id: user.id}).run
+
+# Supported in OccamsRecord 1.9+
+OccamsRecord.sql("SELECT * FROM orders WHERE user_id = :user_id", {user_id: user.id}).run
+OccamsRecord.sql("SELECT * FROM orders WHERE user_id = ?", [user.id]).run
+OccamsRecord.sql("SELECT * FROM orders WHERE user_id = %s", [user.id]).run
+```
+
 **Batched loading with cursors**
 
 `find_each_with_cursor`, `find_in_batches_with_cursor`, and `cursor.open` are all available.
@@ -262,9 +205,9 @@ Let's say we want to load each product with an array of all customers who've ord
 ```ruby
 products_with_orders = OccamsRecord
   .query(Product.all)
-  .eager_load(:line_items) {
-    eager_load(:order) {
-      eager_load(:customer)
+  .eager_load(:line_items) { |l|
+    l.eager_load(:order) { |l|
+      l.eager_load(:customer)
     }
   }
   .map { |product|
@@ -298,7 +241,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
@@ -321,6 +268,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
@@ -332,7 +296,6 @@ The following ActiveRecord features are under consideration, but not high priori
 The following ActiveRecord features are not supported, and likely never will be. Pull requests are still welcome, though.
 
 * Eager loading `through` associations that involve a polymorphic association.
-* ActiveRecord enum types
 * ActiveRecord serialized types
 
 ---
@@ -347,32 +310,50 @@ On the other hand, Active Record makes it *very* easy to forget to eager load as
 
 # Testing
 
-```bash
-bundle install
-
-# test against SQLite
-bundle exec rake test
+Tests are run with `appraisal` in Docker Compose using the `bin/test` or `bin/testall` scripts.
 
-# test against Postgres
-TEST_DATABASE_URL=postgres://postgres@localhost:5432/occams_record bundle exec rake test
-
-# test against MySQL
-TEST_DATABASE_URL=mysql2://root:@127.0.0.1:3306/occams_record bundle exec rake test
+```bash
+# Run tests against all supported ActiveRecord versions, Ruby versions, and databases
+bin/testall
+
+# Run tests for Ruby vX only
+bin/testall ruby-3.1
+
+# Run tests for ActiveRecord vX only
+bin/testall ar-6.1
+
+# Run tests against a specific database
+bin/testall sqlite|postgres-14|mysql-8
+
+# Run exactly one set of tests
+bin/test ruby-3.1 ar-7.0 postgres-14
+
+# If all tests complete successfully, you'll be rewarded by an ASCII Nyancat!
+
++      o     +              o
+    +             o     +       +
+o          +
+    o  +           +        +
++        o     o       +        o
+-_-_-_-_-_-_-_,------,      o
+_-_-_-_-_-_-_-|   /\_/\
+-_-_-_-_-_-_-~|__( ^ .^)  +     +
+_-_-_-_-_-_-_-""  ""
+    +      o         o   +       o
+    +         +
+o        o         o      o     +
+    o           +
++      +     o        o      +
 ```
 
-**Test against all supported ActiveRecord versions**
+## Testing without Docker
 
-```bash
-bundle exec appraisal install
-
-# test against all supported AR versions (defaults to SQLite)
-bundle exec appraisal rake test
+It's possible to run tests without Docker Compose, but you'll be limited by the Ruby version(s) and database(s) you have on your system.
 
-# test against a specific AR version
+```bash
+bundle install
+bundle exec appraisal ar-7.0 bundle install
 bundle exec appraisal ar-7.0 rake test
-
-# test against Postgres
-TEST_DATABASE_URL=postgresql://postgres@localhost:5432/occams_record bundle exec appraisal rake test
 ```
 
 # License

data/lib/occams-record/batches/offset_limit/raw_query.rb

@@ -9,8 +9,12 @@ module OccamsRecord
           @conn, @sql, @binds = conn, sql, binds
           @use, @query_logger, @eager_loaders = use, query_logger, eager_loaders
 
+          unless binds.is_a? Hash
+            raise ArgumentError, "When using find_each/find_in_batches with raw SQL, binds MUST be a Hash. SQL statement: #{@sql}"
+          end
+
           unless @sql =~ /LIMIT\s+%\{batch_limit\}/i and @sql =~ /OFFSET\s+%\{batch_offset\}/i
-            raise ArgumentError, "When using find_each/find_in_batches you must specify 'LIMIT %{batch_limit} OFFSET %{batch_offset}'. SQL statement: #{@sql}"
+            raise ArgumentError, "When using find_each/find_in_batches with raw SQL, you must specify 'LIMIT %{batch_limit} OFFSET %{batch_offset}'. SQL statement: #{@sql}"
           end
         end
 

data/lib/occams-record/binds_converter/abstract.rb

@@ -0,0 +1,71 @@
+module OccamsRecord
+  module BindsConverter
+    #
+    # A base class for converting a SQL string with Rails-style query params (?, :foo) to native Ruby format (%s, %{foo}).
+    #
+    # It works kind of like a tokenizer. Subclasses must 1) implement get_bind to return the converted bind
+    # from the current position and 2) pass the bind sigil (e.g. ?, :) to the parent constructor.
+    #
+    class Abstract
+      # @private
+      ESCAPE = "\\".freeze
+
+      def initialize(sql, bind_sigil)
+        @sql = sql
+        @end = sql.size - 1
+        @start_i, @i = 0, 0
+        @bind_sigil = bind_sigil
+      end
+
+      # @return [String] The converted SQL string
+      def to_s
+        sql = ""
+        each { |frag| sql << frag }
+        sql
+      end
+
+      protected
+
+      # Yields each SQL fragment and converted bind to the given block
+      def each
+        escape = false
+        until @i > @end
+          char = @sql[@i]
+          unescape = escape
+          case char
+          when @bind_sigil
+            if escape
+              @i += 1
+            elsif @i > @start_i
+              yield flush_sql
+            else
+              yield get_bind
+            end
+          when ESCAPE
+            if escape
+              @i += 1
+            elsif @i > @start_i
+              yield flush_sql
+              escape = true
+              @i += 1
+              @start_i = @i
+            else
+              escape = true
+              @i += 1
+            end
+          else
+            @i += 1
+          end
+          escape = false if unescape
+        end
+        yield flush_sql if @i > @start_i
+      end
+
+      def flush_sql
+        t = @sql[@start_i..@i - 1]
+        @start_i = @i
+        t
+      end
+    end
+  end
+end

data/lib/occams-record/binds_converter/named.rb

@@ -0,0 +1,35 @@
+module OccamsRecord
+  module BindsConverter
+    # @private
+    WORD = /\w/
+
+    #
+    # Converts Rails-style named binds (:foo) into native Ruby format (%{foo}).
+    #
+    class Named < Abstract
+      def initialize(sql)
+        super(sql, ":".freeze)
+      end
+
+      protected
+
+      def get_bind
+        old_i = @i
+        @i += 1
+        @start_i = @i
+
+        until @i > @end or @sql[@i] !~ WORD
+          @i += 1
+        end
+
+        if @i > @start_i
+          name = @sql[@start_i..@i - 1]
+          @start_i = @i
+          "%{#{name}}"
+        else
+          @sql[old_i]
+        end
+      end
+    end
+  end
+end

data/lib/occams-record/binds_converter/positional.rb

@@ -0,0 +1,20 @@
+module OccamsRecord
+  module BindsConverter
+    #
+    # Converts Rails-style positional binds (?) into native Ruby format (%s).
+    #
+    class Positional < Abstract
+      def initialize(sql)
+        super(sql, "?".freeze)
+      end
+
+      protected
+
+      def get_bind
+        @i += 1
+        @start_i = @i
+        "%s".freeze
+      end
+    end
+  end
+end

data/lib/occams-record/binds_converter.rb

@@ -0,0 +1,23 @@
+module OccamsRecord
+  #
+  # Classes and methods for converting from Rails-style binds (?, :foo) to native Ruby format (%s, %{foo}).
+  #
+  module BindsConverter
+    #
+    # Convert any Rails-style binds (?, :foo) to native Ruby format (%s, %{foo}).
+    #
+    # @param sql [String]
+    # @param binds [Hash|Array]
+    # @return [String] the converted SQL string
+    #
+    def self.convert(sql, binds)
+      converter =
+        case binds
+        when Hash then Named.new(sql)
+        when Array then Positional.new(sql)
+        else raise ArgumentError, "OccamsRecord: Unsupported SQL bind params '#{binds.inspect}'. Only Hash and Array are supported"
+        end
+      converter.to_s
+    end
+  end
+end

data/lib/occams-record/cursor.rb

@@ -203,9 +203,8 @@ module OccamsRecord
     #   end
     #
     def execute(sql, binds = {})
-      conn.execute(sql % binds.reduce({}) { |acc, (key, val)|
+      conn.execute(sql % binds.each_with_object({}) { |(key, val), acc|
         acc[key] = conn.quote(val)
-        acc
       })
     end
 

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,13 +26,21 @@ 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)
-        instance_exec(&builder) if builder
+        @tracer = Tracer.new(name, parent)
+        @eager_loaders = EagerLoaders::Context.new(@model, tracer: @tracer)
+        if builder
+          if builder.arity > 0
+            builder.call(self)
+          else
+            instance_exec(&builder)
+          end
+        end
       end
 
       #
@@ -37,12 +51,13 @@ module OccamsRecord
       #
       def run(rows, query_logger: nil, measurements: nil)
         fkey_binds = calc_fkey_binds rows
-        assoc = if fkey_binds.all? { |_, vals| vals.any? }
-                  binds = @binds.merge(fkey_binds)
-                  RawQuery.new(@sql, binds, use: @use, eager_loaders: @eager_loaders, query_logger: query_logger, measurements: measurements).run
-                else
-                  []
-                end
+        assoc =
+          if fkey_binds.all? { |_, vals| vals.any? }
+            binds = @binds.merge(fkey_binds)
+            RawQuery.new(@sql, binds, use: @use, eager_loaders: @eager_loaders, query_logger: query_logger, measurements: measurements).run
+          else
+            []
+          end
         merge! assoc, rows
         nil
       end
@@ -55,17 +70,15 @@ module OccamsRecord
       # @param rows [Array<OccamsRecord::Results::Row>] Array of rows used to calculate the query.
       #
       def calc_fkey_binds(rows)
-        @mapping.keys.reduce({}) { |a, fkey|
-          a[fkey.to_s.pluralize.to_sym] = rows.reduce(Set.new) { |aa, row|
+        @mapping.keys.each_with_object({}) { |fkey, acc|
+          acc[fkey.to_s.pluralize.to_sym] = rows.each_with_object(Set.new) { |row, acc2|
             begin
               val = row.send fkey
-              aa << val if val
+              acc2 << val if val
             rescue NoMethodError => e
               raise MissingColumnError.new(row, e.name)
             end
-            aa
           }.to_a
-          a
         }
       end
 

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,15 +22,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. 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)
-        @ref, @scope, @use, @as = ref, scope, use, as
+      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
-        instance_exec(&builder) if builder
+        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
       #
       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
@@ -71,7 +101,7 @@ module OccamsRecord
       def base_scope
         q = @ref.klass.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/belongs_to.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.association_primary_key => ids)
         yield q if ids.any?