jit_preloader 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: e859fc3b5826b985e1b51721bb6d05dc215b2434b250e553f85606ffba196ce3
-  data.tar.gz: d3637cf1b4cf27da79db1ad6dea4be978d9091ae96278abc2cbd02d5c2256076
+SHA1:
+  metadata.gz: ed5a725f8d7f312a774f6a1a3c58e0f1345027d4
+  data.tar.gz: 9d0ef45b43032043aee85d162343bd51783a94e3
 SHA512:
-  metadata.gz: a2d6a3f714be0c14a0f026d4b824f0c4f2176818af5338e94af11f5fe83af41b81181368e32ea42ad0cf00b5a78de598fd8010b77afe36b8ee01745ac9dca236
-  data.tar.gz: fc80b435fa33b15f6686ca061943f050497f6485edd4b63d0a7c505403cfb8fe6019b85615f195b6d6b02fd09cf325970f93e1b3e8c7503bd42ec37f1df5f2c6
+  metadata.gz: 5db4eb1d7b2fc74a2c7a0e8e0e7238b88e6270495f0b8cca71ed31de85da9ced40092186ab1dc188b25dc759d40a0d014288cc1f161534baf48943a684cf906a
+  data.tar.gz: 5ccd2555def314a25a8a022f2aac717e5114ac65a5b32a6fc31c9ffdf176d7db54ff8834ca01962bc037b09bda0a6182204478e387b457c081b03542a9321aa6

data/.gitignore

@@ -43,7 +43,7 @@ build-iPhoneSimulator/
 
 # for a library or gem, you might want to ignore these files since the code is
 # intended to run in multiple environments; otherwise, check them in:
-# Gemfile.lock
+Gemfile.lock
 # .ruby-version
 # .ruby-gemset
 

data/README.md

@@ -173,6 +173,43 @@ end
 
 ```
 
+### Preloading a subset of an association
+
+There are often times when you want to preload a subset of an association, or change how the SQL statement is generated. For example, if a `Contact` model has
+an `addresses` association, you may want to be able to get all of the addresses that belong to a specific country without introducing an N+1 query.
+This is a method `preload_scoped_relation` that is available that can handle this for you.
+
+```ruby
+#old
+class Contact < ActiveRecord::Base
+  has_many :addresses
+  has_many :usa_addresses, ->{ where(country: Country.find_by_name("USA")) }
+end
+
+Contact.jit_preload.all.each do |contact|
+  # This will preload the association as expected, but it must be defined as an association in advance
+  contact.usa_addresses
+
+  # This will preload as the entire addresses association, and filters it in memory
+  contact.addresses.select{|address| address.country == Country.find_by_name("USA") }
+
+  # This is an N+1 query
+  contact.addresses.where(country: Country.find_by_name("USA"))
+end
+
+# New
+Contact.jit_preload.all.each do |contact|
+  contact.preload_scoped_relation(
+    name: "USA Addresses",
+    base_association: :addresses,
+    preload_scope: Address.where(country: Country.find_by_name("USA"))
+  )
+end
+# SELECT * FROM contacts
+# SELECT * FROM countries WHERE name = "USA" LIMIT 1
+# SELECT "addresses".* FROM "addresses" WHERE "addresses"."country_id" = 10 AND "addresses"."contact_id" IN (1, 2, 3, ...)
+```
+
 ### Jit preloading globally across your application
 
 The JitPreloader can be globally enabled, in which case most N+1 queries in your app should just disappear. It is off by default.
@@ -201,7 +238,7 @@ This is mostly a magic bullet, but it doesn't solve all database-related problem
 ```ruby
 Contact.all.each do |contact|
   contact.emails.reload                         # Reloading the association
-  contact.addresses.where(billing: true).to_a   # Querying the association
+  contact.addresses.where(billing: true).to_a   # Querying the association (Use: preload_scoped_relation to avoid these)
 end
 ```
 
@@ -215,7 +252,7 @@ end
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/jit_preloader/fork )
+1. Fork it ( https://github.com/clio/jit_preloader/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/jit_preloader.gemspec

@@ -18,13 +18,14 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", "> 4.2", "< 6"
+  spec.add_dependency "activerecord", "> 4.2", "< 7"
   spec.add_dependency "activesupport"
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "database_cleaner"
   spec.add_development_dependency "sqlite3"
   spec.add_development_dependency "byebug"
+  spec.add_development_dependency "db-query-matchers"
 end

data/lib/jit_preloader.rb

@@ -8,16 +8,17 @@ require 'jit_preloader/active_record/base'
 require 'jit_preloader/active_record/relation'
 require 'jit_preloader/active_record/associations/collection_association'
 require 'jit_preloader/active_record/associations/singular_association'
-if Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("5.2.2")
+if Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new("6.0.0")
+  require 'jit_preloader/active_record/associations/preloader/ar6_association'
+elsif Gem::Version.new(ActiveRecord::VERSION::STRING) >= Gem::Version.new("5.2.2")
+  require 'jit_preloader/active_record/associations/preloader/ar5_association'
+else
   require 'jit_preloader/active_record/associations/preloader/collection_association'
   require 'jit_preloader/active_record/associations/preloader/singular_association'
-else
-  require 'jit_preloader/active_record/associations/preloader/association'
 end
 require 'jit_preloader/preloader'
 
 module JitPreloader
-
   def self.globally_enabled=(value)
     @enabled = value
   end

data/lib/jit_preloader/active_record/associations/preloader/ar6_association.rb

@@ -0,0 +1,69 @@
+module JitPreloader
+  module PreloaderAssociation
+
+    # A monkey patch to ActiveRecord. The old method looked like the snippet
+    # below. Our changes here are that we remove records that are already
+    # part of the target, then attach all of the records to a new jit preloader.
+    #
+    # def run
+    #   if !preload_scope || preload_scope.empty_scope?
+    #     owners.each do |owner|
+    #       associate_records_to_owner(owner, records_by_owner[owner] || [])
+    #     end
+    #   else
+    #     # Custom preload scope is used and
+    #     # the association can not be marked as loaded
+    #     # Loading into a Hash instead
+    #     records_by_owner
+    #   end
+    #   self
+    # end
+    def run
+      all_records = []
+
+      owners.each do |owner|
+        owned_records = records_by_owner[owner] || []
+        all_records.concat(Array(owned_records)) if owner.jit_preloader || JitPreloader.globally_enabled?
+        associate_records_to_owner(owner, owned_records)
+      end
+
+      JitPreloader::Preloader.attach(all_records) if all_records.any?
+
+      self
+    end
+
+    # Original method:
+    # def associate_records_to_owner(owner, records)
+    #   association = owner.association(reflection.name)
+    #   association.loaded!
+    #   if reflection.collection?
+    #     association.target.concat(records)
+    #   else
+    #     association.target = records.first unless records.empty?
+    #   end
+    # end
+    def associate_records_to_owner(owner, records)
+      association = owner.association(reflection.name)
+      association.loaded!
+
+      if reflection.collection?
+        # It is possible that some of the records are loaded already.
+        # We don't want to duplicate them, but we also want to preserve
+        # the original copy so that we don't blow away in-memory changes.
+        new_records = association.target.any? ? records - association.target : records
+        association.target.concat(new_records)
+      else
+        association.target ||= records.first unless records.empty?
+      end
+    end
+
+
+    def build_scope
+      super.tap do |scope|
+        scope.jit_preload! if owners.any?(&:jit_preloader) || JitPreloader.globally_enabled?
+      end
+    end
+  end
+end
+
+ActiveRecord::Associations::Preloader::Association.prepend(JitPreloader::PreloaderAssociation)

data/lib/jit_preloader/active_record/base.rb

@@ -1,74 +1,119 @@
 module JitPreloadExtension
+  attr_accessor :jit_preloader
+  attr_accessor :jit_n_plus_one_tracking
+  attr_accessor :jit_preload_aggregates
+  attr_accessor :jit_preload_scoped_relations
 
-  extend ActiveSupport::Concern
+  def reload(*args)
+    clear_jit_preloader!
+    super
+  end
+
+  def clear_jit_preloader!
+    self.jit_preload_aggregates = {}
+    self.jit_preload_scoped_relations = {}
+    if jit_preloader
+      jit_preloader.records.delete(self)
+      self.jit_preloader = nil
+    end
+  end
+
+  def preload_scoped_relation(name:, base_association:, preload_scope: nil)
+    return jit_preload_scoped_relations[name] if jit_preload_scoped_relations&.key?(name)
 
-  included do
-    attr_accessor :jit_preloader
-    attr_accessor :jit_n_plus_one_tracking
-    attr_accessor :jit_preload_aggregates
+    records = jit_preloader&.records || [self]
+    previous_association_values = {}
 
-    def reload(*args)
-      clear_jit_preloader!
-      super
+    records.each do |record|
+      association = record.association(base_association)
+      if association.loaded?
+        previous_association_values[record] = association.target
+        association.reset
+      end
     end
 
-    def clear_jit_preloader!
-      self.jit_preload_aggregates = {}
-      if jit_preloader
-        jit_preloader.records.delete(self)
-        self.jit_preloader = nil
+    ActiveRecord::Associations::Preloader.new.preload(
+      records,
+      base_association,
+      preload_scope
+    )
+
+    records.each do |record|
+      record.jit_preload_scoped_relations ||= {}
+      association = record.association(base_association)
+      record.jit_preload_scoped_relations[name] = association.target
+      association.reset
+      if previous_association_values.key?(record)
+        association.target = previous_association_values[record]
       end
     end
 
+    jit_preload_scoped_relations[name]
   end
 
-  class_methods do
-    delegate :jit_preload, to: :all
+  def self.prepended(base)
+    class << base
+      delegate :jit_preload, to: :all
 
-    def has_many_aggregate(assoc, name, aggregate, field, default: 0)
-      method_name = "#{assoc}_#{name}"
+      def has_many_aggregate(assoc, name, aggregate, field, table_alias_name: nil, default: 0)
+        method_name = "#{assoc}_#{name}"
 
-      define_method(method_name) do |conditions={}|
-        self.jit_preload_aggregates ||= {}
+        define_method(method_name) do |conditions={}|
+          self.jit_preload_aggregates ||= {}
 
-        key = "#{method_name}|#{conditions.sort.hash}"
-        return jit_preload_aggregates[key] if jit_preload_aggregates.key?(key)
-        if jit_preloader
-          reflection = association(assoc).reflection
-          primary_ids = jit_preloader.records.collect{|r| r[reflection.active_record_primary_key] }
-          klass = reflection.klass
+          key = "#{method_name}|#{conditions.sort.hash}"
+          return jit_preload_aggregates[key] if jit_preload_aggregates.key?(key)
+          if jit_preloader
+            reflection = association(assoc).reflection
+            primary_ids = jit_preloader.records.collect{|r| r[reflection.active_record_primary_key] }
+            klass = reflection.klass
 
-          aggregate_association = reflection
-          while aggregate_association.through_reflection
-            aggregate_association = aggregate_association.through_reflection
-          end
+            aggregate_association = reflection
+            while aggregate_association.through_reflection
+              aggregate_association = aggregate_association.through_reflection
+            end
 
-          association_scope = klass.all.merge(association(assoc).scope).unscope(where: aggregate_association.foreign_key)
-          association_scope = association_scope.instance_exec(&reflection.scope).reorder(nil) if reflection.scope
+            association_scope = klass.all.merge(association(assoc).scope).unscope(where: aggregate_association.foreign_key)
+            association_scope = association_scope.instance_exec(&reflection.scope).reorder(nil) if reflection.scope
 
-          conditions[aggregate_association.table_name] = { aggregate_association.foreign_key => primary_ids }
-          if reflection.type.present?
-            conditions[reflection.type] = self.class.name
-          end
-          group_by = "#{aggregate_association.table_name}.#{aggregate_association.foreign_key}"
+            # If the query uses an alias for the association, use that instead of the table name
+            table_reference = table_alias_name
+            table_reference ||= association_scope.references_values.first || aggregate_association.table_name
+
+            conditions[table_reference] = { aggregate_association.foreign_key => primary_ids }
+
+            # If the association is a STI child model, specify its type in the condition so that it
+            # doesn't include results from other child models
+            parent_is_base_class = aggregate_association.klass.superclass.abstract_class? || aggregate_association.klass.superclass == ActiveRecord::Base
+            has_type_column = aggregate_association.klass.column_names.include?(aggregate_association.klass.inheritance_column)
+            is_child_sti_model = !parent_is_base_class && has_type_column
+            if is_child_sti_model
+              conditions[table_reference].merge!({ aggregate_association.klass.inheritance_column => aggregate_association.klass.sti_name })
+            end
+
+            if reflection.type.present?
+              conditions[reflection.type] = self.class.name
+            end
+            group_by = "#{table_reference}.#{aggregate_association.foreign_key}"
 
-          preloaded_data = Hash[association_scope
-            .where(conditions)
-            .group(group_by)
-            .send(aggregate, field)
-          ]
+            preloaded_data = Hash[association_scope
+              .where(conditions)
+              .group(group_by)
+              .send(aggregate, field)
+            ]
 
-          jit_preloader.records.each do |record|
-            record.jit_preload_aggregates ||= {}
-            record.jit_preload_aggregates[key] = preloaded_data[record.id] || default
+            jit_preloader.records.each do |record|
+              record.jit_preload_aggregates ||= {}
+              record.jit_preload_aggregates[key] = preloaded_data[record.id] || default
+            end
+          else
+            self.jit_preload_aggregates[key] = send(assoc).where(conditions).send(aggregate, field) || default
           end
-        else
-          self.jit_preload_aggregates[key] = send(assoc).where(conditions).send(aggregate, field) || default
+          jit_preload_aggregates[key]
         end
-        jit_preload_aggregates[key]
       end
     end
   end
 end
 
-ActiveRecord::Base.send(:include, JitPreloadExtension)
+ActiveRecord::Base.send(:prepend, JitPreloadExtension)

data/lib/jit_preloader/version.rb

@@ -1,3 +1,3 @@
 module JitPreloader
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/spec/lib/jit_preloader/active_record/base_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require "db-query-matchers"
+
+RSpec.describe "ActiveRecord::Base Extensions" do
+
+  let(:canada) { Country.create(name: "Canada") }
+  let(:usa) { Country.create(name: "U.S.A") }
+
+  describe "#preload_scoped_relation" do
+    def call(contact)
+      contact.preload_scoped_relation(
+        name: "American Addresses",
+        base_association: :addresses,
+        preload_scope: Address.where(country: usa)
+      )
+    end
+
+    before do
+      Contact.create(name: "Bar", addresses: [
+        Address.new(street: "123 Fake st", country: canada),
+        Address.new(street: "21 Jump st", country: usa),
+        Address.new(street: "90210 Beverly Hills", country: usa)
+      ])
+
+      Contact.create(name: "Foo", addresses: [
+        Address.new(street: "1 First st", country: canada),
+        Address.new(street: "10 Tenth Ave", country: usa)
+      ])
+    end
+
+    context "when operating on a single object" do
+      it "will load the objects for that object" do
+        contact = Contact.first
+        expect(call(contact)).to match_array contact.addresses.where(country: usa).to_a
+      end
+    end
+
+    it "memoizes the result" do
+      contacts = Contact.jit_preload.limit(2).to_a
+
+      expect do
+        expect(call(contacts.first))
+        expect(call(contacts.first))
+      end.to make_database_queries(count: 1)
+    end
+
+    context "when reloading the object" do
+      it "clears the memoization" do
+        contacts = Contact.jit_preload.limit(2).to_a
+
+        expect do
+          expect(call(contacts.first))
+        end.to make_database_queries(count: 1)
+        contacts.first.reload
+        expect do
+          expect(call(contacts.first))
+        end.to make_database_queries(count: 1)
+      end
+    end
+
+    it "will issue one query for the group of objects" do
+      contacts = Contact.jit_preload.limit(2).to_a
+
+      usa_addresses = contacts.first.addresses.where(country: usa).to_a
+      expect do
+        expect(call(contacts.first)).to match_array usa_addresses
+      end.to make_database_queries(count: 1)
+
+      usa_addresses = contacts.last.addresses.where(country: usa).to_a
+      expect do
+        expect(call(contacts.last)).to match_array usa_addresses
+      end.to_not make_database_queries
+    end
+
+    it "doesn't load the value into the association" do
+      contacts = Contact.jit_preload.limit(2).to_a
+      call(contacts.first)
+
+      expect(contacts.first.association(:addresses)).to_not be_loaded
+      expect(contacts.last.association(:addresses)).to_not be_loaded
+    end
+
+    context "when the association is already loaded" do
+      it "doesn't change the value of the association" do
+        contacts = Contact.jit_preload.limit(2).to_a
+        contacts.each{|contact| contact.addresses.to_a }
+        contacts.each{|contact| call(contact) }
+
+        expect(contacts.first.association(:addresses)).to be_loaded
+        expect(contacts.last.association(:addresses)).to be_loaded
+      end
+    end
+  end
+end

data/spec/lib/jit_preloader/preloader_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe JitPreloader::Preloader do
-
   let!(:contact1) do
     addresses = [
       Address.new(street: "123 Fake st", country: canada),
@@ -49,6 +48,79 @@ RSpec.describe JitPreloader::Preloader do
     ->(event, data){ source_map[data[:source]] << data[:association] }
   end
 
+  context "for single table inheritance" do
+    context "when preloading an aggregate for a child model" do
+      let!(:contact_book) { ContactBook.create(name: "The Yellow Pages") }
+      let!(:company1) { Company.create(name: "Company1", contact_book: contact_book) }
+      let!(:company2) { Company.create(name: "Company2", contact_book: contact_book) }
+
+      it "can handle queries" do
+        contact_books = ContactBook.jit_preload.to_a
+        expect(contact_books.first.companies_count).to eq 2
+      end
+    end
+
+    context "when preloading an aggregate of a child model through its base model" do
+      let!(:contact_book) { ContactBook.create(name: "The Yellow Pages") }
+      let!(:contact) { Contact.create(name: "Contact", contact_book: contact_book) }
+      let!(:company1) { Company.create(name: "Company1", contact_book: contact_book) }
+      let!(:company2) { Company.create(name: "Company2", contact_book: contact_book) }
+      let!(:contact_employee1) { Employee.create(name: "Contact Employee1", contact: contact) }
+      let!(:contact_employee2) { Employee.create(name: "Contact Employee2", contact: contact) }
+      let!(:company_employee1) { Employee.create(name: "Company Employee1", contact: company1) }
+      let!(:company_employee2) { Employee.create(name: "Company Employee2", contact: company2) }
+
+      it "can handle queries" do
+        contact_books = ContactBook.jit_preload.to_a
+        expect(contact_books.first.employees_count).to eq 4
+      end
+    end
+
+    context "when preloading an aggregate of a nested child model through another child model" do
+      let!(:contact_book) { ContactBook.create(name: "The Yellow Pages") }
+      let!(:contact) { Contact.create(name: "Contact", contact_book: contact_book) }
+      let!(:company1) { Company.create(name: "Company1", contact_book: contact_book) }
+      let!(:company2) { Company.create(name: "Company2", contact_book: contact_book) }
+      let!(:contact_employee1) { Employee.create(name: "Contact Employee1", contact: contact) }
+      let!(:contact_employee2) { Employee.create(name: "Contact Employee2", contact: contact) }
+      let!(:company_employee1) { Employee.create(name: "Company Employee1", contact: company1) }
+      let!(:company_employee2) { Employee.create(name: "Company Employee2", contact: company2) }
+
+      it "can handle queries" do
+        contact_books = ContactBook.jit_preload.to_a
+        expect(contact_books.first.company_employees_count).to eq 2
+      end
+    end
+
+    context "when preloading an aggregate of a nested child model through a many-to-many relationship with another child model" do
+      let!(:contact_book) { ContactBook.create(name: "The Yellow Pages") }
+      let!(:child1) { Child.create(name: "Child1") }
+      let!(:child2) { Child.create(name: "Child2") }
+      let!(:child3) { Child.create(name: "Child3") }
+      let!(:parent1) { Parent.create(name: "Parent1", contact_book: contact_book, children: [child1, child2]) }
+      let!(:parent2) { Parent.create(name: "Parent2", contact_book: contact_book, children: [child2, child3]) }
+
+      it "can handle queries" do
+        contact_books = ContactBook.jit_preload.to_a
+        expect(contact_books.first.children_count).to eq 4
+        expect(contact_books.first.children).to include(child1, child2, child3)
+      end
+    end
+
+    context "when preloading an aggregate for a child model scoped by another join table" do
+      let!(:contact_book) { ContactBook.create(name: "The Yellow Pages") }
+      let!(:contact1) { Company.create(name: "Without Email", contact_book: contact_book) }
+      let!(:contact2) { Company.create(name: "With Blank Email", email_address: EmailAddress.new(address: ""), contact_book: contact_book) }
+      let!(:contact3) { Company.create(name: "With Email", email_address: EmailAddress.new(address: "a@a.com"), contact_book: contact_book) }
+
+      it "can handle queries" do
+        contact_books = ContactBook.jit_preload.to_a
+        expect(contact_books.first.companies_with_blank_email_address_count).to eq 1
+        expect(contact_books.first.companies_with_blank_email_address).to eq [contact2]
+      end
+    end
+  end
+
   context "when preloading an aggregate as polymorphic" do
     let(:contact_owner_counts) { [2] }
 

data/spec/support/database.rb

@@ -1,12 +1,14 @@
 class Database
   def self.tables
     [
-      "CREATE TABLE contacts (id INTEGER NOT NULL PRIMARY KEY, name VARCHAR(255), contact_owner_id INTEGER, contact_owner_type VARCHAR(255))",
+      "CREATE TABLE contact_books (id INTEGER NOT NULL PRIMARY KEY, name VARCHAR(255))",
+      "CREATE TABLE contacts (id INTEGER NOT NULL PRIMARY KEY, type VARCHAR(255), contact_book_id INTEGER, contact_id INTEGER, name VARCHAR(255), contact_owner_id INTEGER, contact_owner_type VARCHAR(255))",
       "CREATE TABLE contact_owners (id INTEGER NOT NULL PRIMARY KEY, name VARCHAR(255))",
       "CREATE TABLE addresses (id INTEGER NOT NULL PRIMARY KEY, contact_id INTEGER NOT NULL, country_id INTEGER NOT NULL, street VARCHAR(255))",
       "CREATE TABLE email_addresses (id INTEGER NOT NULL PRIMARY KEY, contact_id INTEGER NOT NULL, address VARCHAR(255))",
       "CREATE TABLE phone_numbers (id INTEGER NOT NULL PRIMARY KEY, contact_id INTEGER NOT NULL, phone VARCHAR(10))",
       "CREATE TABLE countries (id INTEGER NOT NULL PRIMARY KEY, name VARCHAR(255))",
+      "CREATE TABLE parents_children (id INTEGER NOT NULL PRIMARY KEY, parent_id INTEGER, child_id INTEGER)",
     ]
   end
 

data/spec/support/models.rb

@@ -1,15 +1,58 @@
+class ContactBook < ActiveRecord::Base
+  has_many :contacts
+  has_many :employees, through: :contacts
+
+  has_many :companies
+  has_many :company_employees, through: :companies, source: :employees
+
+  has_many :parents
+  has_many :children, through: :parents
+
+  has_many_aggregate :companies, :count, :count, "*"
+  has_many_aggregate :employees, :count, :count, "*"
+  has_many_aggregate :company_employees, :count, :count, "*"
+  has_many_aggregate :children, :count, :count, "*"
+
+  has_many :companies_with_blank_email_address, -> { joins(:email_address).where(email_addresses: { address: "" }) }, class_name: "Company"
+  has_many_aggregate :companies_with_blank_email_address, :count, :count, "*", table_alias_name: "contacts"
+end
+
 class Contact < ActiveRecord::Base
+  belongs_to :contact_book
   belongs_to :contact_owner, polymorphic: true
 
   has_many :addresses
   has_many :phone_numbers
   has_one :email_address
+  has_many :employees
 
   has_many_aggregate :addresses, :max_street_length, :maximum, "LENGTH(street)"
   has_many_aggregate :phone_numbers, :count, :count, "id"
   has_many_aggregate :addresses, :count, :count, "*"
 end
 
+class Company < Contact
+end
+
+class Employee < Contact
+  belongs_to :contact
+end
+
+class ParentsChild < ActiveRecord::Base
+  belongs_to :parent
+  belongs_to :child
+end
+
+class Parent < Contact
+  has_many :parents_child
+  has_many :children, through: :parents_child
+end
+
+class Child < Contact
+  has_many :parents_child
+  has_many :parents, through: :parents_child
+end
+
 class Address < ActiveRecord::Base
   belongs_to :contact
   belongs_to :country

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jit_preloader
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Kyle d'Oliveira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-16 00:00:00.000000000 Z
+date: 2020-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -128,6 +128,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: db-query-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The JitPreloader has the ability to send notifications when N+1 queries
   occur to help guage how problematic they are for your code base and a way to remove
   all of the commons explicitly or automatically
@@ -140,15 +154,14 @@ files:
 - ".gitignore"
 - ".rspec"
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - Rakefile
 - jit_preloader.gemspec
 - lib/jit_preloader.rb
 - lib/jit_preloader/active_record/associations/collection_association.rb
-- lib/jit_preloader/active_record/associations/preloader/association.rb
-- lib/jit_preloader/active_record/associations/preloader/association.rb~
+- lib/jit_preloader/active_record/associations/preloader/ar5_association.rb
+- lib/jit_preloader/active_record/associations/preloader/ar6_association.rb
 - lib/jit_preloader/active_record/associations/preloader/collection_association.rb
 - lib/jit_preloader/active_record/associations/preloader/singular_association.rb
 - lib/jit_preloader/active_record/associations/singular_association.rb
@@ -156,6 +169,7 @@ files:
 - lib/jit_preloader/active_record/relation.rb
 - lib/jit_preloader/preloader.rb
 - lib/jit_preloader/version.rb
+- spec/lib/jit_preloader/active_record/base_spec.rb
 - spec/lib/jit_preloader/preloader_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.rb
@@ -179,11 +193,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Tool to understand N+1 queries and to remove them
 test_files:
+- spec/lib/jit_preloader/active_record/base_spec.rb
 - spec/lib/jit_preloader/preloader_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.rb

data/Gemfile.lock

@@ -1,62 +0,0 @@
-PATH
-  remote: .
-  specs:
-    jit_preloader (0.2.1)
-      activerecord (> 4.2, < 6)
-      activesupport
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    activemodel (5.2.2)
-      activesupport (= 5.2.2)
-    activerecord (5.2.2)
-      activemodel (= 5.2.2)
-      activesupport (= 5.2.2)
-      arel (>= 9.0)
-    activesupport (5.2.2)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    arel (9.0.0)
-    byebug (9.0.6)
-    concurrent-ruby (1.1.4)
-    database_cleaner (1.5.3)
-    diff-lcs (1.2.5)
-    i18n (1.6.0)
-      concurrent-ruby (~> 1.0)
-    minitest (5.11.3)
-    rake (10.5.0)
-    rspec (3.5.0)
-      rspec-core (~> 3.5.0)
-      rspec-expectations (~> 3.5.0)
-      rspec-mocks (~> 3.5.0)
-    rspec-core (3.5.4)
-      rspec-support (~> 3.5.0)
-    rspec-expectations (3.5.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-mocks (3.5.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.5.0)
-    rspec-support (3.5.0)
-    sqlite3 (1.3.12)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler
-  byebug
-  database_cleaner
-  jit_preloader!
-  rake (~> 10.0)
-  rspec
-  sqlite3
-
-BUNDLED WITH
-   2.0.1

data/lib/jit_preloader/active_record/associations/preloader/association.rb~

@@ -1,34 +0,0 @@
-class ActiveRecord::Associations::Preloader::Association
-  private
-  # A monkey patch to ActiveRecord. The old method looked like the snippet
-  # below. Our changes here are that we remove records that are already
-  # part of the target, then attach all of the records to a new jit preloader.
-  #
-  # def preload(preloader)
-  #   associated_records_by_owner(preloader).each do |owner, records|
-  #     association = owner.association(reflection.name)
-  #     association.loaded!
-  #     association.target.concat(records)
-  #     records.each { |record| association.set_inverse_instance(record) }
-  #   end
-  # end
-
-  def preload(preloader)
-    return unless (reflection.scope.nil? || reflection.scope.arity == 0) && klass.ancestors.include?(ActiveRecord::Base)
-    all_records = []
-    associated_records_by_owner(preloader).each do |owner, records|
-      association = owner.association(reflection.name)
-      association.loaded!
-      # It is possible that some of the records are loaded already.
-      # We don't want to duplicate them, but we also want to preserve
-      # the original copy so that we don't blow away in-memory changes.
-      new_records = association.target.any? ? records - association.target : records
-
-      association.target.concat(new_records)
-      new_records.each { |record| association.set_inverse_instance(record) }
-
-      all_records.concat(records) if owner.jit_preloader || JitPreloader.globally_enabled?
-    end
-    JitPreloader::Preloader.attach(all_records) if all_records.any?
-  end
-end