activerecord_where_assoc 0.1.3 → 1.1.2

data/lib/active_record_where_assoc.rb

@@ -4,23 +4,34 @@ require_relative "active_record_where_assoc/version"
 require "active_record"
 
 module ActiveRecordWhereAssoc
-  # Default options for the gem. Meant to be modified in place by external code
+  # Default options for the gem. Meant to be modified in place by external code, such as in
+  # an initializer.
+  # Ex:
+  #   ActiveRecordWhereAssoc.default_options[:ignore_limit] = true
+  #
+  # A description for each can be found in RelationReturningMethods@Options.
+  #
+  # :ignore_limit is the only one to consider changing, when you are using MySQL, since limit are
+  # never supported on it. Otherwise, the safety of having to pass the options yourself
+  # and noticing you made a mistake / avoiding the need for extra queries is worth the extra code.
   def self.default_options
     @default_options ||= {
                            ignore_limit: false,
                            never_alias_limit: false,
+                           poly_belongs_to: :raise,
                          }
   end
 end
 
 require_relative "active_record_where_assoc/core_logic"
-require_relative "active_record_where_assoc/query_methods"
-require_relative "active_record_where_assoc/querying"
+require_relative "active_record_where_assoc/relation_returning_methods"
+require_relative "active_record_where_assoc/relation_returning_delegates"
+require_relative "active_record_where_assoc/sql_returning_methods"
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord.eager_load!
 
-  # Need to use #send for the include to support Ruby 2.0
-  ActiveRecord::Relation.send(:include, ActiveRecordWhereAssoc::QueryMethods)
-  ActiveRecord::Base.extend(ActiveRecordWhereAssoc::Querying)
+  ActiveRecord::Relation.include(ActiveRecordWhereAssoc::RelationReturningMethods)
+  ActiveRecord::Base.extend(ActiveRecordWhereAssoc::RelationReturningDelegates)
+  ActiveRecord::Base.extend(ActiveRecordWhereAssoc::SqlReturningMethods)
 end

data/lib/active_record_where_assoc/active_record_compat.rb

@@ -2,23 +2,35 @@
 
 module ActiveRecordWhereAssoc
   module ActiveRecordCompat
-    if ActiveRecord.gem_version >= Gem::Version.new("5.1")
-      def self.join_keys(reflection)
-        reflection.join_keys
+    if ActiveRecord.gem_version >= Gem::Version.new("6.1.0.rc1")
+      JoinKeys = Struct.new(:key, :foreign_key)
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        if poly_belongs_to_klass
+          JoinKeys.new(reflection.join_primary_key(poly_belongs_to_klass), reflection.join_foreign_key)
+        else
+          JoinKeys.new(reflection.join_primary_key, reflection.join_foreign_key)
+        end
+      end
+
+    elsif ActiveRecord.gem_version >= Gem::Version.new("5.1")
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        if poly_belongs_to_klass
+          reflection.get_join_keys(poly_belongs_to_klass)
+        else
+          reflection.join_keys
+        end
       end
     elsif ActiveRecord.gem_version >= Gem::Version.new("4.2")
-      def self.join_keys(reflection)
-        reflection.join_keys(reflection.klass)
+      def self.join_keys(reflection, poly_belongs_to_klass)
+        reflection.join_keys(poly_belongs_to_klass || reflection.klass)
       end
     else
       # 4.1 change that introduced JoinKeys:
       # https://github.com/rails/rails/commit/5823e429981dc74f8f53187d2ab573823381bf28#diff-523caff658498027f61cae9d91c8503dL108
       JoinKeys = Struct.new(:key, :foreign_key)
-      def self.join_keys(reflection)
+      def self.join_keys(reflection, poly_belongs_to_klass)
         if reflection.source_macro == :belongs_to
-          # The original code had to handle polymorphic here. But we don't support polymorphic belongs_to
-          # So the code would never reach here in the polymorphic case.
-          key = reflection.association_primary_key
+          key = reflection.association_primary_key(poly_belongs_to_klass)
           foreign_key = reflection.foreign_key
         else
           key         = reflection.foreign_key
@@ -31,7 +43,17 @@ module ActiveRecordWhereAssoc
 
     if ActiveRecord.gem_version >= Gem::Version.new("5.0")
       def self.chained_reflection_and_chained_constraints(reflection)
-        reflection.chain.map { |ref| [ref, ref.constraints] }.transpose
+        pairs = reflection.chain.map do |ref|
+          # PolymorphicReflection is a super weird thing. Like a partial reflection, I don't get it.
+          # Seems like just bypassing it works for our needs.
+          # When doing a has_many through that has a polymorphic source and a source_type, this ends up
+          # part of the chain instead of the regular HasManyReflection that one would expect.
+          ref = ref.instance_variable_get(:@reflection) if ref.is_a?(ActiveRecord::Reflection::PolymorphicReflection)
+
+          [ref, ref.constraints]
+        end
+
+        pairs.transpose
       end
     else
       def self.chained_reflection_and_chained_constraints(reflection)
@@ -59,5 +81,15 @@ module ActiveRecordWhereAssoc
         association_name.to_sym
       end
     end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("5.0")
+      def self.through_reflection?(reflection)
+        reflection.through_reflection?
+      end
+    else
+      def self.through_reflection?(reflection)
+        reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+      end
+    end
   end
 end

data/lib/active_record_where_assoc/core_logic.rb

@@ -8,21 +8,39 @@ module ActiveRecordWhereAssoc
     # Arel table used for aliasing when handling recursive associations (such as parent/children)
     ALIAS_TABLE = Arel::Table.new("_ar_where_assoc_alias_")
 
-    # Block used when nesting associations for a where_assoc_[not_]exists
-    # Will apply the nested scope to the wrapping_scope with: where("EXISTS (SELECT... *nested_scope*)")
-    # exists_prefix: raw sql prefix to the EXISTS, ex: 'NOT '
-    NestWithExistsBlock = lambda do |wrapping_scope, nested_scope, exists_prefix = ""|
-      sql = "#{exists_prefix}EXISTS (#{nested_scope.select('1').to_sql})"
+    # Returns the SQL for checking if any of the received relation exists.
+    # Uses a OR if there are multiple relations.
+    # => "EXISTS (SELECT... *relation1*) OR EXISTS (SELECT... *relation2*)"
+    def self.sql_for_any_exists(relations)
+      relations = [relations] unless relations.is_a?(Array)
+      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      sqls = relations.map { |rel| "EXISTS (#{rel.select('1').to_sql})" }
+      if sqls.size > 1
+        "(#{sqls.join(" OR ")})" # Parens needed when embedding the sql in a `where`, because the OR could make things wrong
+      elsif sqls.size == 1
+        sqls.first
+      else
+        "0=1"
+      end
+    end
 
-      wrapping_scope.where(sql)
+    # Block used when nesting associations for a where_assoc_[not_]exists
+    NestWithExistsBlock = lambda do |wrapping_scope, nested_scopes|
+      wrapping_scope.where(sql_for_any_exists(nested_scopes))
     end
 
-    # Block used when nesting associations for a where_assoc_count
-    # Will apply the nested scope to the wrapping_scope with: select("SUM(SELECT... *nested_scope*)")
-    NestWithSumBlock = lambda do |wrapping_scope, nested_scope|
+    # Returns the SQL for getting the sum of of the received relations
+    # => "SUM((SELECT... *relation1*)) + SUM((SELECT... *relation2*))"
+    def self.sql_for_sum_of_counts(relations)
+      relations = [relations] unless relations.is_a?(Array)
+      relations = relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
       # Need the double parentheses
-      sql = "SUM((#{nested_scope.to_sql}))"
+      relations.map { |rel| "SUM((#{rel.to_sql}))" }.join(" + ").presence || "0"
+    end
 
+    # Block used when nesting associations for a where_assoc_count
+    NestWithSumBlock = lambda do |wrapping_scope, nested_scopes|
+      sql = sql_for_sum_of_counts(nested_scopes)
       wrapping_scope.unscope(:select).select(sql)
     end
 
@@ -39,66 +57,83 @@ module ActiveRecordWhereAssoc
       options.fetch(key) { ActiveRecordWhereAssoc.default_options[key] }
     end
 
-    # Returns a new relation, which is the result of filtering base_relation
-    # based on if a record for the specified association of the model exists.
+    # Returns the SQL condition to check if the specified association of the record_class exists (has records).
     #
-    # See #where_assoc_exists in query_methods.rb for usage details.
-    def self.do_where_assoc_exists(base_relation, association_name, given_scope, options, &block)
-      nested_relation = relation_on_association(base_relation, association_name, given_scope, options, block, NestWithExistsBlock)
-      NestWithExistsBlock.call(base_relation, nested_relation)
+    # See RelationReturningMethods#where_assoc_exists or SqlReturningMethods#assoc_exists_sql for usage details.
+    def self.assoc_exists_sql(record_class, association_names, given_conditions, options, &block)
+      nested_relations = relations_on_association(record_class, association_names, given_conditions, options, block, NestWithExistsBlock)
+      sql_for_any_exists(nested_relations)
     end
 
-    # Returns a new relation, which is the result of filtering base_relation
-    # based on if a record for the specified association of the model doesn't exist.
+    # Returns the SQL condition to check if the specified association of the record_class doesn't exist (has no records).
     #
-    # See #where_assoc_exists in query_methods.rb for usage details.
-    def self.do_where_assoc_not_exists(base_relation, association_name, given_scope, options, &block)
-      nested_relation = relation_on_association(base_relation, association_name, given_scope, options, block, NestWithExistsBlock)
-      NestWithExistsBlock.call(base_relation, nested_relation, "NOT ")
+    # See RelationReturningMethods#where_assoc_not_exists or SqlReturningMethods#assoc_not_exists_sql for usage details.
+    def self.assoc_not_exists_sql(record_class, association_names, given_conditions, options, &block)
+      nested_relations = relations_on_association(record_class, association_names, given_conditions, options, block, NestWithExistsBlock)
+      "NOT #{sql_for_any_exists(nested_relations)}"
     end
 
-    # Returns a new relation, which is the result of filtering base_relation
-    # based on how many records for the specified association of the model exists.
+    # This does not return an SQL condition. Instead, it returns only the SQL to count the number of records for the specified
+    # association.
     #
-    # See #where_assoc_exists and #where_assoc_count in query_methods.rb for usage details.
-    def self.do_where_assoc_count(base_relation, left_operand, operator, association_name, given_scope, options, &block)
+    # See SqlReturningMethods#only_assoc_count_sql for usage details.
+    def self.only_assoc_count_sql(record_class, association_names, given_conditions, options, &block)
       deepest_scope_mod = lambda do |deepest_scope|
         deepest_scope = apply_proc_scope(deepest_scope, block) if block
 
         deepest_scope.unscope(:select).select("COUNT(*)")
       end
 
-      nested_relation = relation_on_association(base_relation, association_name, given_scope, options, deepest_scope_mod, NestWithSumBlock)
+      nested_relations = relations_on_association(record_class, association_names, given_conditions, options, deepest_scope_mod, NestWithSumBlock)
+      nested_relations = nested_relations.reject { |rel| rel.is_a?(ActiveRecord::NullRelation) }
+      nested_relations.map { |nr| "COALESCE((#{nr.to_sql}), 0)" }.join(" + ").presence || "0"
+    end
+
+    # Returns the SQL condition to check if the specified association of the record_class has the desired number of records.
+    #
+    # See RelationReturningMethods#where_assoc_count or SqlReturningMethods#compare_assoc_count_sql for usage details.
+    def self.compare_assoc_count_sql(record_class, left_operand, operator, association_names, given_conditions, options, &block)
+      right_sql = only_assoc_count_sql(record_class, association_names, given_conditions, options, &block)
 
-      sql = sql_for_count_operator(left_operand, operator, "COALESCE((#{nested_relation.to_sql}), 0)")
-      base_relation.where(sql)
+      sql_for_count_operator(left_operand, operator, right_sql)
     end
 
-    # Returns the receiver (with possible alterations) and a relation meant to be embed in the received.
-    # association_names_path: can be an array of association names or a single one
-    def self.relation_on_association(base_relation, association_names_path, given_scope, options, last_assoc_block, nest_assocs_block)
+    # Returns relations on the associated model meant to be embedded in a query
+    # Will only return more than one association when there are polymorphic belongs_to
+    # association_names: can be an array of association names or a single one
+    def self.relations_on_association(record_class, association_names, given_conditions, options, last_assoc_block, nest_assocs_block)
       validate_options(options)
-      association_names_path = Array.wrap(association_names_path)
+      association_names = Array.wrap(association_names)
+      _relations_on_association_recurse(record_class, association_names, given_conditions, options, last_assoc_block, nest_assocs_block)
+    end
 
-      if association_names_path.size > 1
+    def self._relations_on_association_recurse(record_class, association_names, given_conditions, options, last_assoc_block, nest_assocs_block)
+      if association_names.size > 1
         recursive_scope_block = lambda do |scope|
-          nested_scope = relation_on_association(scope, association_names_path[1..-1], given_scope, options, last_assoc_block, nest_assocs_block)
+          nested_scope = _relations_on_association_recurse(scope,
+                                                           association_names[1..-1],
+                                                           given_conditions,
+                                                           options,
+                                                           last_assoc_block,
+                                                           nest_assocs_block)
           nest_assocs_block.call(scope, nested_scope)
         end
 
-        relation_on_one_association(base_relation, association_names_path.first, nil, options, recursive_scope_block, nest_assocs_block)
+        relations_on_one_association(record_class, association_names.first, nil, options, recursive_scope_block, nest_assocs_block)
       else
-        relation_on_one_association(base_relation, association_names_path.first, given_scope, options, last_assoc_block, nest_assocs_block)
+        relations_on_one_association(record_class, association_names.first, given_conditions, options, last_assoc_block, nest_assocs_block)
       end
     end
 
-    # Returns the receiver (with possible alterations) and a relation meant to be embed in the received.
-    def self.relation_on_one_association(base_relation, association_name, given_scope, options, last_assoc_block, nest_assocs_block)
-      relation_klass = base_relation.klass
-      final_reflection = fetch_reflection(relation_klass, association_name)
+    # Returns relations on the associated model meant to be embedded in a query
+    # Will return more than one association only for polymorphic belongs_to
+    def self.relations_on_one_association(record_class, association_name, given_conditions, options, last_assoc_block, nest_assocs_block)
+      final_reflection = fetch_reflection(record_class, association_name)
+
+      check_reflection_validity!(final_reflection)
 
-      nested_scope = nil
-      current_scope = nil
+      nested_scopes = nil
+      current_scopes = nil
 
       # Chain deals with through stuff
       # We will start with the reflection that points on the final model, and slowly move back to the reflection
@@ -118,24 +153,35 @@ module ActiveRecordWhereAssoc
         # the 2nd part of has_and_belongs_to_many is handled at the same time as the first.
         skip_next = true if actually_has_and_belongs_to_many?(reflection)
 
-        wrapper_scope, current_scope = initial_scope_from_reflection(reflection_chain[i..-1], constaints_chain[i])
-
-        current_scope = process_association_step_limits(current_scope, reflection, relation_klass, options)
-
-        if i.zero?
-          current_scope = current_scope.where(given_scope) if given_scope
-          current_scope = apply_proc_scope(current_scope, last_assoc_block) if last_assoc_block
+        init_scopes = initial_scopes_from_reflection(reflection_chain[i..-1], constaints_chain[i], options)
+        current_scopes = init_scopes.map do |alias_scope, current_scope, klass_scope|
+          current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
+
+          if i.zero?
+            current_scope = current_scope.where(given_conditions) if given_conditions
+            if klass_scope
+              if klass_scope.respond_to?(:call)
+                current_scope = apply_proc_scope(current_scope, klass_scope)
+              else
+                current_scope = current_scope.where(klass_scope)
+              end
+            end
+            current_scope = apply_proc_scope(current_scope, last_assoc_block) if last_assoc_block
+          end
+
+          # Those make no sense since at this point, we are only limiting the value that would match using conditions
+          # Those could have been added by the received block, so just remove them
+          current_scope = current_scope.unscope(:limit, :order, :offset)
+
+          current_scope = nest_assocs_block.call(current_scope, nested_scopes) if nested_scopes
+          current_scope = nest_assocs_block.call(alias_scope, current_scope) if alias_scope
+          current_scope
         end
 
-        # Those make no sense since we are only limiting the value that would match, using conditions
-        current_scope = current_scope.unscope(:limit, :order, :offset)
-        current_scope = nest_assocs_block.call(current_scope, nested_scope) if nested_scope
-        current_scope = nest_assocs_block.call(wrapper_scope, current_scope) if wrapper_scope
-
-        nested_scope = current_scope
+        nested_scopes = current_scopes
       end
 
-      current_scope
+      current_scopes
     end
 
     def self.fetch_reflection(relation_klass, association_name)
@@ -146,68 +192,75 @@ module ActiveRecordWhereAssoc
         # Need to use build because this exception expects a record...
         raise ActiveRecord::AssociationNotFoundError.new(relation_klass.new, association_name)
       end
-      if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-        # TODO: We might want an option to indicate that using pluck is ok?
-        raise NotImplementedError, "Can't deal with polymorphic belongs_to"
-      end
 
       reflection
     end
 
-    def self.initial_scope_from_reflection(reflection_chain, constraints)
+    # Can return multiple pairs for polymorphic belongs_to, one per table to look into
+    def self.initial_scopes_from_reflection(reflection_chain, assoc_scopes, options)
       reflection = reflection_chain.first
-      current_scope = reflection.klass.default_scoped
-
-      if actually_has_and_belongs_to_many?(reflection)
-        # has_and_belongs_to_many, behind the scene has a secret model and uses a has_many through.
-        # This is the first of those two secret has_many through.
-        #
-        # In order to handle limit, offset, order correctly on has_and_belongs_to_many,
-        # we must do both this reflection and the next one at the same time.
-        # Think of it this way, if you have limit 3:
-        #   Apply only on 1st step: You check that any of 2nd step for the first 3 of 1st step match
-        #   Apply only on 2nd step: You check that any of the first 3 of second step match for any 1st step
-        #   Apply over both (as we do): You check that only the first 3 of doing both step match,
-
-        # To create the join, simply using next_reflection.klass.default_scoped.joins(reflection.name)
-        # would be great, except we cannot add a given_scope afterward because we are on the wrong "base class",
-        # and we can't do #merge because of the LEW crap.
-        # So we must do the joins ourself!
-        _wrapper, sub_join_contraints = wrapper_and_join_constraints(reflection)
-        next_reflection = reflection_chain[1]
-
-        current_scope = current_scope.joins(<<-SQL)
-            INNER JOIN #{next_reflection.klass.quoted_table_name} ON #{sub_join_contraints.to_sql}
-        SQL
-
-        wrapper_scope, join_constaints = wrapper_and_join_constraints(next_reflection, habtm_other_reflection: reflection)
-      else
-        wrapper_scope, join_constaints = wrapper_and_join_constraints(reflection)
-      end
-
-      constraint_allowed_lim_off = constraint_allowed_lim_off_from(reflection)
-
-      constraints.each do |callable|
-        relation = reflection.klass.unscoped.instance_exec(&callable)
+      actual_source_reflection = user_defined_actual_source_reflection(reflection)
+
+      on_poly_belongs_to = option_value(options, :poly_belongs_to) if poly_belongs_to?(actual_source_reflection)
+
+      classes_with_scope = classes_with_scope_for_reflection(reflection, options)
+
+      assoc_scope_allowed_lim_off = assoc_scope_to_keep_lim_off_from(reflection)
+
+      classes_with_scope.map do |klass, klass_scope|
+        current_scope = klass.default_scoped
+
+        if actually_has_and_belongs_to_many?(actual_source_reflection)
+          # has_and_belongs_to_many, behind the scene has a secret model and uses a has_many through.
+          # This is the first of those two secret has_many through.
+          #
+          # In order to handle limit, offset, order correctly on has_and_belongs_to_many,
+          # we must do both this reflection and the next one at the same time.
+          # Think of it this way, if you have limit 3:
+          #   Apply only on 1st step: You check that any of 2nd step for the first 3 of 1st step match
+          #   Apply only on 2nd step: You check that any of the first 3 of second step match for any 1st step
+          #   Apply over both (as we do): You check that only the first 3 of doing both step match,
+
+          # To create the join, simply using next_reflection.klass.default_scoped.joins(reflection.name)
+          # would be great, except we cannot add a given_conditions afterward because we are on the wrong "base class",
+          # and we can't do #merge because of the LEW crap.
+          # So we must do the joins ourself!
+          _wrapper, sub_join_contraints = wrapper_and_join_constraints(reflection)
+          next_reflection = reflection_chain[1]
+
+          current_scope = current_scope.joins(<<-SQL)
+              INNER JOIN #{next_reflection.klass.quoted_table_name} ON #{sub_join_contraints.to_sql}
+          SQL
+
+          alias_scope, join_constaints = wrapper_and_join_constraints(next_reflection, habtm_other_reflection: reflection)
+        elsif on_poly_belongs_to
+          alias_scope, join_constaints = wrapper_and_join_constraints(reflection, poly_belongs_to_klass: klass)
+        else
+          alias_scope, join_constaints = wrapper_and_join_constraints(reflection)
+        end
 
-        if callable != constraint_allowed_lim_off
-          # I just want to remove the current values without screwing things in the merge below
-          # so we cannot use #unscope
-          relation.limit_value = nil
-          relation.offset_value = nil
-          relation.order_values = []
+        assoc_scopes.each do |callable|
+          relation = klass.unscoped.instance_exec(nil, &callable)
+
+          if callable != assoc_scope_allowed_lim_off
+            # I just want to remove the current values without screwing things in the merge below
+            # so we cannot use #unscope
+            relation.limit_value = nil
+            relation.offset_value = nil
+            relation.order_values = []
+          end
+
+          # Need to use merge to replicate the Last Equality Wins behavior of associations
+          # https://github.com/rails/rails/issues/7365
+          # See also the test/tests/wa_last_equality_wins_test.rb for an explanation
+          current_scope = current_scope.merge(relation)
         end
 
-        # Need to use merge to replicate the Last Equality Wins behavior of associations
-        # https://github.com/rails/rails/issues/7365
-        # See also the test/tests/wa_last_equality_wins_test.rb for an explanation
-        current_scope = current_scope.merge(relation)
+        [alias_scope, current_scope.where(join_constaints), klass_scope]
       end
-
-      [wrapper_scope, current_scope.where(join_constaints)]
     end
 
-    def self.constraint_allowed_lim_off_from(reflection)
+    def self.assoc_scope_to_keep_lim_off_from(reflection)
       # For :through associations, it's pretty hard/tricky to apply limit/offset/order of the
       # whole has_* :through. For now, we only apply those of the direct associations from one model
       # to another that the :through uses and we ignore the limit/offset/order from the scope of has_* :through.
@@ -219,12 +272,63 @@ module ActiveRecordWhereAssoc
       user_defined_actual_source_reflection(reflection).scope
     end
 
+    def self.classes_with_scope_for_reflection(reflection, options)
+      actual_source_reflection = user_defined_actual_source_reflection(reflection)
+
+      if poly_belongs_to?(actual_source_reflection)
+        on_poly_belongs_to = option_value(options, :poly_belongs_to)
+
+        if reflection.options[:source_type]
+          [reflection.options[:source_type].safe_constantize].compact
+        else
+          case on_poly_belongs_to
+          when :pluck
+            class_names = actual_source_reflection.active_record.distinct.pluck(actual_source_reflection.foreign_type)
+            class_names.compact.map!(&:safe_constantize).compact
+          when Array, Hash
+            array = on_poly_belongs_to.to_a
+            bad_class = array.detect { |c, _p| !c.is_a?(Class) || !(c < ActiveRecord::Base) }
+            if bad_class.is_a?(ActiveRecord::Base)
+              raise ArgumentError, "Must receive the Class of the model, not an instance. This is wrong: #{bad_class.inspect}"
+            elsif bad_class
+              raise ArgumentError, "Expected #{bad_class.inspect} to be a subclass of ActiveRecord::Base"
+            end
+            array
+          when :raise
+            msg = String.new
+            if actual_source_reflection == reflection
+              msg << "Association #{reflection.name.inspect} is a polymorphic belongs_to. "
+            else
+              msg << "Association #{reflection.name.inspect} is a :through relation that uses a polymorphic belongs_to"
+              msg << "#{actual_source_reflection.name.inspect} as source without without a source_type. "
+            end
+            msg << "This is not supported by ActiveRecord when doing joins, but it is by WhereAssoc. However, "
+            msg << "you must pass the :poly_belongs_to option to specify what to do in this case.\n"
+            msg << "See https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/RelationReturningMethods.html#module-ActiveRecordWhereAssoc::RelationReturningMethods-label-3Apoly_belongs_to+option"
+            raise ActiveRecordWhereAssoc::PolymorphicBelongsToWithoutClasses, msg
+          else
+            if on_poly_belongs_to.is_a?(Class) && on_poly_belongs_to < ActiveRecord::Base
+              [on_poly_belongs_to]
+            else
+              raise ArgumentError, "Received a bad value for :poly_belongs_to: #{on_poly_belongs_to.inspect}"
+            end
+          end
+        end
+      else
+        [reflection.klass]
+      end
+    end
+
+    # Creates a sub_query that the current_scope gets nested into if there is limit/offset to apply
     def self.process_association_step_limits(current_scope, reflection, relation_klass, options)
-      return current_scope.unscope(:limit, :offset, :order) if user_defined_actual_source_reflection(reflection).macro == :belongs_to
+      if user_defined_actual_source_reflection(reflection).macro == :belongs_to || option_value(options, :ignore_limit)
+        return current_scope.unscope(:limit, :offset, :order)
+      end
 
-      current_scope = current_scope.limit(1) if reflection.macro == :has_one
+      # No need to do transformations if this is already a NullRelation
+      return current_scope if current_scope.is_a?(ActiveRecord::NullRelation)
 
-      current_scope = current_scope.unscope(:limit, :offset) if option_value(options, :ignore_limit)
+      current_scope = current_scope.limit(1) if reflection.macro == :has_one
 
       # Order is useless without either limit or offset
       current_scope = current_scope.unscope(:order) if !current_scope.limit_value && !current_scope.offset_value
@@ -234,7 +338,7 @@ module ActiveRecordWhereAssoc
         msg = String.new
         msg << "Associations and default_scopes with a limit or offset are not supported for MySQL (this includes has_many). "
         msg << "Use ignore_limit: true to ignore both limit and offset, and treat has_one like has_many. "
-        msg << "See https://github.com/MaxLap/activerecord_where_assoc/tree/ignore_limits#mysql-doesnt-support-sub-limit for details."
+        msg << "See https://github.com/MaxLap/activerecord_where_assoc#mysql-doesnt-support-sub-limit for details."
         raise MySQLDoesntSupportSubLimitError, msg
       end
 
@@ -250,10 +354,7 @@ module ActiveRecordWhereAssoc
       # be useful.
 
       if reflection.klass.table_name.include?(".") || option_value(options, :never_alias_limit)
-        # This works universally, but seems to sometimes have slower performances.. Need to test if there is an alternative way
-        # of expressing this...
-        # TODO: Investigate a way to improve performances, or maybe require a flag to do it this way?
-        # We use unscoped to avoid duplicating the conditions in the query, which is noise. (unless if it
+        # We use unscoped to avoid duplicating the conditions in the query, which is noise. (unless it
         # could helps the query planner of the DB, if someone can show it to be worth it, then this can be changed.)
 
         reflection.klass.unscoped.where(reflection.klass.primary_key.to_sym => current_scope)
@@ -272,30 +373,32 @@ module ActiveRecordWhereAssoc
     # If it can receive arguments, call the proc the relation passed as argument
     def self.apply_proc_scope(relation, proc_scope)
       if proc_scope.arity == 0
-        relation.instance_exec(&proc_scope) || relation
+        relation.instance_exec(nil, &proc_scope) || relation
       else
         proc_scope.call(relation) || relation
       end
     end
 
-    def self.build_wrapper_scope_for_recursive_association(reflection)
-      table = reflection.klass.arel_table
-      primary_key = reflection.klass.primary_key
+    def self.build_alias_scope_for_recursive_association(reflection, poly_belongs_to_klass)
+      klass = poly_belongs_to_klass || reflection.klass
+      table = klass.arel_table
+      primary_key = klass.primary_key
       foreign_klass = reflection.send(:actual_source_reflection).active_record
 
-      wrapper_scope = foreign_klass.base_class.unscoped
-      wrapper_scope = wrapper_scope.from("#{table.name} #{ALIAS_TABLE.name}")
-      wrapper_scope = wrapper_scope.where(table[primary_key].eq(ALIAS_TABLE[primary_key]))
-      wrapper_scope
+      alias_scope = foreign_klass.base_class.unscoped
+      alias_scope = alias_scope.from("#{table.name} #{ALIAS_TABLE.name}")
+      alias_scope = alias_scope.where(table[primary_key].eq(ALIAS_TABLE[primary_key]))
+      alias_scope
     end
 
     def self.wrapper_and_join_constraints(reflection, options = {})
-      join_keys = ActiveRecordCompat.join_keys(reflection)
+      poly_belongs_to_klass = options[:poly_belongs_to_klass]
+      join_keys = ActiveRecordCompat.join_keys(reflection, poly_belongs_to_klass)
 
       key = join_keys.key
       foreign_key = join_keys.foreign_key
 
-      table = reflection.klass.arel_table
+      table = (poly_belongs_to_klass || reflection.klass).arel_table
       foreign_klass = reflection.send(:actual_source_reflection).active_record
       foreign_table = foreign_klass.arel_table
 
@@ -303,25 +406,36 @@ module ActiveRecordWhereAssoc
       habtm_other_table = habtm_other_reflection.klass.arel_table if habtm_other_reflection
 
       if (habtm_other_table || table).name == foreign_table.name
-        wrapper_scope = build_wrapper_scope_for_recursive_association(habtm_other_reflection || reflection)
+        alias_scope = build_alias_scope_for_recursive_association(habtm_other_reflection || reflection, poly_belongs_to_klass)
         foreign_table = ALIAS_TABLE
       end
 
       constraints = table[key].eq(foreign_table[foreign_key])
 
       if reflection.type
-        # Handing of the polymorphic has_many/has_one's type column
+        # Handling of the polymorphic has_many/has_one's type column
         constraints = constraints.and(table[reflection.type].eq(foreign_klass.base_class.name))
       end
 
-      [wrapper_scope, constraints]
+      if poly_belongs_to_klass
+        constraints = constraints.and(foreign_table[reflection.foreign_type].eq(poly_belongs_to_klass.base_class.name))
+      end
+
+      [alias_scope, constraints]
     end
 
+    # Because we work using Model._reflections, we don't actually get the :has_and_belongs_to_many.
+    # Instead, we get a has_many :through, which is was ActiveRecord created behind the scene.
+    # This code detects that a :through is actually a has_and_belongs_to_many.
     def self.has_and_belongs_to_many?(reflection) # rubocop:disable Naming/PredicateName
       parent = ActiveRecordCompat.parent_reflection(reflection)
       parent && parent.macro == :has_and_belongs_to_many
     end
 
+    def self.poly_belongs_to?(reflection)
+      reflection.macro == :belongs_to && reflection.options[:polymorphic]
+    end
+
     # Return true if #user_defined_actual_source_reflection is a has_and_belongs_to_many
     def self.actually_has_and_belongs_to_many?(reflection)
       has_and_belongs_to_many?(user_defined_actual_source_reflection(reflection))
@@ -339,6 +453,26 @@ module ActiveRecordWhereAssoc
       end
     end
 
+    def self.check_reflection_validity!(reflection)
+      if ActiveRecordCompat.through_reflection?(reflection)
+        # Copied from ActiveRecord
+        if reflection.through_reflection.polymorphic?
+          # Since deep_cover/builtin_takeover lacks some granularity,
+          # it can sometimes happen that it won't display 100% coverage while a regular would
+          # be 100%. This happens when multiple banches are on in a single line.
+          # For this reason, I split this condition in 2
+          if ActiveRecord.const_defined?(:HasOneAssociationPolymorphicThroughError)
+            if reflection.has_one?
+              raise ActiveRecord::HasOneAssociationPolymorphicThroughError.new(reflection.active_record.name, reflection)
+            end
+          end
+          raise ActiveRecord::HasManyThroughAssociationPolymorphicThroughError.new(reflection.active_record.name, reflection)
+        end
+        check_reflection_validity!(reflection.through_reflection)
+        check_reflection_validity!(reflection.source_reflection)
+      end
+    end
+
     # Doing (SQL) BETWEEN v1 AND v2, where v2 is infinite means (SQL) >= v1. However,
     # we place the SQL on the right side, so the operator is flipped to become v1 <= (SQL).
     # Doing (SQL) NOT BETWEEN v1 AND v2 where v2 is infinite means (SQL) < v1. However,
@@ -368,11 +502,12 @@ module ActiveRecordWhereAssoc
       v1 = left_operand.begin
       v2 = left_operand.end || Float::INFINITY
 
+      # We are doing a count and summing them, the lowest possible is 0, so just use that instead of changing the SQL used.
       v1 = 0 if v1 == -Float::INFINITY
 
       return sql_for_count_operator(v1, RIGHT_INFINITE_RANGE_OPERATOR_MAP.fetch(operator), right_sql) if v2 == Float::INFINITY
 
-      # Its int or a float with no mantissa, exclude_end? means -1
+      # Its int or a rounded float. Since we are comparing to integer values (count), exclude_end? just means -1
       v2 -= 1 if left_operand.exclude_end? && v2 % 1 == 0
 
       "#{right_sql} #{RANGE_OPERATOR_MAP.fetch(operator)} #{v1} AND #{v2}"