activerecord_where_assoc 1.1.5 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 366ed8e028f8ed692b13cd8c487385ec380c57f41ce51edcd3370a2412ffe8f3
-  data.tar.gz: c6d2c1b2111cda267e7c5c6555692317ad0188cd748972f262acbdcba02eee7e
+  metadata.gz: ad309caebf6c729645f97a3c76959f0e61557b956fe86fe13dac641af06f87d4
+  data.tar.gz: 7f4967c6493d13550f31036753a50606f7e82f9fed1d5277b06db899517e89ec
 SHA512:
-  metadata.gz: 1dd9b3955c50ec5ed37ca032b7aa20d93eac2ab035a914e1032efe1527a7b86cd33cd3832c3fa68010bfafef4780f2dfba473e99fa0f089bb3649c8aed578c27
-  data.tar.gz: 6bae922127f45e21c2484c3ef28f0d47512cb1d2cc0b1e94a97a628277698eceb04595b3f96759d367be1e94e4441ad72e8e2901aabf44169994989579b68d00
+  metadata.gz: 0efde09f38bd4c4913ac3b4cb36d114cb654c0c35bd05c07eb31559801d9febb87b479d9ae41b6bc07d9d77ddef775fd3b1e307ea20a3a10ccf2b829f03f27f1
+  data.tar.gz: ef3d2dbfef7f58f0221cdf5c32448410a1886fd1b8532bbe2d4a8643d5bde2dad5c2029eeddf5cb1b6620ab199b6ec2e3bd313ddd505d648a90d2d2f619b2747

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Unreleased
 
+# 1.2.1 - 2024-12-05
+
+* Optimize `has_one` handling for `#where_assoc_exists` with a `has_one` as last association + without any conditions or offset.
+* Optimize `has_one` handling when the foreign_key has a unique index and there is no offset
+
+# 1.2.0 - 2024-08-31
+
+* Add support for composite primary keys in Rails 7.2
+
 # 1.1.5 - 2024-05-18
 
 * Add compatibility for Rails 7.2
@@ -22,12 +31,12 @@
 
 # 1.1.0 - 2020-02-24
 
-* Added methods which return the SQL used by this gem: `assoc_exists_sql`, `assoc_not_exists_sql`, `compare_assoc_count_sql`, `only_assoc_count_sql`  
+* Added methods which return the SQL used by this gem: `assoc_exists_sql`, `assoc_not_exists_sql`, `compare_assoc_count_sql`, `only_assoc_count_sql`
   [Documentation for them](https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/SqlReturningMethods.html)
 
 # 1.0.1
 
-* Fix broken urls in error messages 
+* Fix broken urls in error messages
 
 # 1.0.0
 
@@ -35,16 +44,16 @@
 
 # 0.1.3
 
-* Use `SELECT 1` instead of `SELECT 0`...  
+* Use `SELECT 1` instead of `SELECT 0`...
   ... it just seems more natural that way.
 * Bugfixes
 
 # 0.1.2
 
-* It is now possible to pass a `Range` as first argument to `#where_assoc_count`.  
+* It is now possible to pass a `Range` as first argument to `#where_assoc_count`.
   Ex: Users that have between 10 and 20 posts
   `User.where_assoc_count(10..20, :==, :posts)`
-  The operator in that case must be either :== or :!=.  
-  This will use `BETWEEN` and `NOT BETWEEN`.  
+  The operator in that case must be either :== or :!=.
+  This will use `BETWEEN` and `NOT BETWEEN`.
   Ranges that exclude the last value, i.e. `5...10`, are also supported, resulting in `BETWEEN 5 and 9`.
   Ranges with infinities are also supported.

data/lib/active_record_where_assoc/active_record_compat.rb

@@ -101,5 +101,28 @@ module ActiveRecordWhereAssoc
         reflection.is_a?(ActiveRecord::NullRelation)
       end
     end
+
+    if ActiveRecord.gem_version >= Gem::Version.new("6.0")
+      def self.indexes(model)
+        model.connection.schema_cache.indexes(model.table_name)
+      end
+    else
+      def self.indexes(model)
+        model.connection.indexes(model.table_name)
+      end
+    end
+
+    @unique_indexes_cache = {}
+    def self.has_unique_index?(model, column_names)
+      column_names = Array(column_names).map(&:to_s)
+      @unique_indexes_cache.fetch([model, column_names]) do |k|
+        unique_indexes = indexes(model).select(&:unique)
+        columns_names_set = Set.new(column_names)
+
+        # We check for an index whose columns are a subset of the columns we specify
+        # This way, a composite column_names will find uniqueness if just a single of the column is unique
+        @unique_indexes_cache[k] = unique_indexes.any? { |ui| Set.new(ui.columns) <= columns_names_set }
+      end
+    end
   end
 end

data/lib/active_record_where_assoc/core_logic.rb

@@ -155,9 +155,17 @@ module ActiveRecordWhereAssoc
 
         init_scopes = initial_scopes_from_reflection(record_class, reflection_chain[i..-1], constraints_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?
+            if given_conditions || klass_scope || last_assoc_block || current_scope.offset_value || nest_assocs_block == NestWithSumBlock
+              # In the deepest layer, the limit & offset complexities only matter when:
+              # * There is a condition to apply
+              # * There is an offset (which is a form of filtering)
+              # * We are counting the total matches
+              # Since last_assoc_block is always set except for the deepest association, and is only unset for the deepest layer if
+              # there is no condition given, using it as part of the condition does a lot of work here.
+              current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
+            end
+
             current_scope = current_scope.where(given_conditions) if given_conditions
             if klass_scope
               if klass_scope.respond_to?(:call)
@@ -167,6 +175,8 @@ module ActiveRecordWhereAssoc
               end
             end
             current_scope = apply_proc_scope(current_scope, last_assoc_block) if last_assoc_block
+          else
+            current_scope = process_association_step_limits(current_scope, reflection, record_class, options)
           end
 
           # Those make no sense since at this point, we are only limiting the value that would match using conditions
@@ -338,10 +348,18 @@ module ActiveRecordWhereAssoc
 
       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
+      if !current_scope.offset_value
+        if current_scope.limit_value
+          join_keys = ActiveRecordCompat.join_keys(reflection, nil)
+          # #join_keys is inverted... the foreign key is on the "source" table, and the key is on the "target" table...
+          # Everything is so complicated in ActiveRecord.
+          current_scope = current_scope.unscope(:limit) if ActiveRecordCompat.has_unique_index?(current_scope.model, join_keys.key)
+        end
+
+        # Order is useless without either limit or offset
+        return current_scope.unscope(:order) if !current_scope.limit_value
+      end
 
-      return current_scope unless current_scope.limit_value || current_scope.offset_value
       if %w(mysql mysql2).include?(relation_klass.connection.adapter_name.downcase)
         msg = String.new
         msg << "Associations and default_scopes with a limit or offset are not supported for MySQL (this includes has_many). "
@@ -364,6 +382,9 @@ module ActiveRecordWhereAssoc
       if reflection.klass.table_name.include?(".") || option_value(options, :never_alias_limit)
         # 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.)
+        if reflection.klass.primary_key.is_a?(Array)
+          raise NeverAliasLimitDoesntWorkWithCompositePrimaryKeysError, "Sorry, it just doesn't work..."
+        end
 
         reflection.klass.unscoped.where(reflection.klass.primary_key.to_sym => current_scope)
       else
@@ -395,8 +416,13 @@ module ActiveRecordWhereAssoc
 
       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
+
+      primary_key_constraints =
+        Array(primary_key).map do |a_primary_key|
+          table[a_primary_key].eq(ALIAS_TABLE[a_primary_key])
+        end
+
+      alias_scope.where(primary_key_constraints.inject(&:and))
     end
 
     def self.wrapper_and_join_constraints(record_class, reflection, options = {})
@@ -424,7 +450,18 @@ module ActiveRecordWhereAssoc
         foreign_table = ALIAS_TABLE
       end
 
-      constraints = table[key].eq(foreign_table[foreign_key])
+      constraint_keys = Array.wrap(key)
+      constraint_foreign_keys = Array.wrap(foreign_key)
+      constraint_key_map = constraint_keys.zip(constraint_foreign_keys)
+
+      primary_foreign_key_constraints =
+        constraint_key_map.map do |primary_and_foreign_keys|
+          a_primary_key, a_foreign_key = primary_and_foreign_keys
+
+          table[a_primary_key].eq(foreign_table[a_foreign_key])
+        end
+
+      constraints = primary_foreign_key_constraints.inject(&:and)
 
       if reflection.type
         # Handling of the polymorphic has_many/has_one's type column

data/lib/active_record_where_assoc/exceptions.rb

@@ -6,4 +6,7 @@ module ActiveRecordWhereAssoc
 
   class PolymorphicBelongsToWithoutClasses < StandardError
   end
+
+  class NeverAliasLimitDoesntWorkWithCompositePrimaryKeysError < StandardError
+  end
 end

data/lib/active_record_where_assoc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordWhereAssoc
-  VERSION = "1.1.5".freeze
+  VERSION = "1.2.1".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_where_assoc
 version: !ruby/object:Gem::Version
-  version: 1.1.5
+  version: 1.2.1
 platform: ruby
 authors:
 - Maxime Handfield Lapointe
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-18 00:00:00.000000000 Z
+date: 2024-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -181,7 +181,7 @@ homepage: https://github.com/MaxLap/activerecord_where_assoc
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -196,8 +196,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: Make ActiveRecord do conditions on your associations
 test_files: []