activerecord-has_some_of_many 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ab0ac9fc08cfe5684f0bc33fb071360ffd130fcb61e6ce582d0372d97875cee
-  data.tar.gz: 747c855f75f1cac9aa5b0419107c8c4b7650db107587c11f1af7633b319cd747
+  metadata.gz: '0290c685fa491a5956467a8fc6109104b1622f27e524efeca9f5d147433214cd'
+  data.tar.gz: 8b39ae1096090a9747198730bd2a98fb87e162dd03f0692dad73b6ea374d37cf
 SHA512:
-  metadata.gz: ee776f879139db208e90494496ca4f311398220aed654184822b586b327465a295f212c7b965a176da8231b5c2506dc8df1d2be5be7b0a0f83be0bec29ebfe02
-  data.tar.gz: 66deb994b6d7524e0c77fd508bfc84ed8d8c55ed7af15655d88c4cccc869bc9a08b366034620fde1f8c3c3406184d1a80d955ebaf91e24be1ef3b9dde2c15f17
+  metadata.gz: 19388466d6c9e3ca6166cef76bc4e376cf6804be4bbafb6232505077e65b293d42d7fbb8e448c95befdc163197f8eac6b812b8bac4c95b1c3557457b0561af8c
+  data.tar.gz: d4752090dd3d5c239550c1ed334583d990512328c2f7cbcf8fc220b845a944779c94e6afb780f5a6c524c976710fa637a6f5a89d75abdfbaa79e5b03afe43007

data/README.md

@@ -1,13 +1,23 @@
 # `activerecord-has_some_of_many`
 
-This gem adds new optimized Active Record association methods (`has_one_of_many`, `has_some_of_many`) for "top N" queries to ActiveRecord using `JOIN LATERAL` that are eager-loadable (`includes(:association)`, `preloads(:association)`) to avoid N+1 queries, and is compatible with typical queries and batch methods (`find_each`, `in_batches`, find_in_batches`). For example, you might have these types of queries in your application:
+This gem adds new optimized Active Record association methods (`has_one_of_many`, `has_some_of_many`) for "top N" queries to ActiveRecord using `JOIN LATERAL` that are eager-loadable (`includes(:association)`, `preloads(:association)`) to avoid N+1 queries, and is compatible with typical queries and batch methods (`find_each`, `in_batches`, `find_in_batches`). For example, you might have these types of queries in your application:
 
-- Users have many posts, and you want to query the most recent post for each user 
+- Users have many posts, and you want to query the most recent post for each user
 - Posts have many comments, and you want to query the 5 most recent visible comments for each post
 - Posts have many comments, and you want to query the one comment with the largest `votes_count` for each post
 
 You can read more about these types of queries on [Benito Serna's "Fetching the top n per group with a lateral join with rails"](https://bhserna.com/fetching-the-top-n-per-group-with-a-lateral-join-with-rails.html).
 
+## Compatibility
+
+This gem is only compatible with databases that offer `LATERAL` joins within Active Record. As far as I'm aware, that is **only Postgres**.
+
+This gem is not necessary on SQLite, as SQLite will perform lateral-like behavior on join queries by default. MySQL has support for lateral queries, but they are not yet implemented in Active Record.
+
+**Really complex queries may not work; please open an issue!** This library works by rewriting Active Record queries; it's possible to create some very complex queries with Active Record. Some things that are specifically known to work:
+  - Model associations to the same model. It works.
+  - _Please help expand this list by opening an issue if you find something that doesn't work!_
+
 ## Usage
 
 Add to your gemfile, and run `bundle install`:
@@ -25,7 +35,7 @@ class User < ActiveRecord::Base
   # You can also use `has_some_of_many` to get the top N records. Be sure to add a limit to the scope.
   has_some_of_many :last_five_posts, -> { order("created_at DESC").limit(5) }, class_name: "Post"
 
-  # More complex scopees are possible, for example:
+  # More complex scopes are possible, for example:
   has_one_of_many :top_comment, -> { where(published: true).order("votes_count DESC") }, class_name: "Comment"
   has_some_of_many :top_ten_comments, -> { where(published: true).order("votes_count DESC").limit(10) }, class_name: "Comment"
 end
@@ -37,17 +47,17 @@ User.where(active: true).includes(:last_post, :last_five_posts, :top_comment).ea
   user.top_comment
 end
 
-# Aad compound indexes to your database to make these queries fast!
+# Add compound indexes to your database to make these queries fast!
 add_index :comments, [:post_id, :created_at]
 add_index :comments, [:post_id, :votes_count]
 ```
 
 ## Why?
 
-Finding the "Top N" is a common problem, that can be easily solved with a `JOIN LATERAL` when writing raw SQL queries. Lateral Joins were introduced in Postgres 9.3: 
+Finding the "Top N" is a common problem, that can be easily solved with a `JOIN LATERAL` when writing raw SQL queries. Lateral Joins were introduced in Postgres 9.3:
 
 > a LATERAL join is like a SQL foreach loop, in which Postgres will iterate over each row in a result set and evaluate a subquery using that row as a parameter. ([source](https://www.heap.io/blog/postgresqls-powerful-new-join-type-lateral))
- 
+
 For example, to find only the one most recent comments for a collection of posts, we might write:
 
 ```sql

data/lib/activerecord/has_some_of_many/associations.rb

@@ -33,7 +33,8 @@ module ActiveRecord
                       .select(klass.arel_table[primary_key].as(foreign_key_alias), lateral_table[Arel.star])
                       .arel.join(
                         relation
-                          .where(relation.arel_table[foreign_key].eq(klass.arel_table[primary_key]))
+                          .then { |query| relation.table.name == klass.arel_table.name ? ActiveRecord::HasSomeOfMany::RelationRewriter.new(query).alias_table("#{klass.table_name}__alias") : query }
+                          .then { |query| query.where(query.table[foreign_key].eq(klass.arel_table[primary_key])) }
                           .then { |query| limit ? query.limit(limit) : query }
                           .arel.lateral(lateral_table.name)
                       ).on("TRUE")

data/lib/activerecord/has_some_of_many/relation_rewriter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module HasSomeOfMany
+    class RelationRewriter
+      def initialize(relation)
+        @relation = relation
+      end
+
+      def alias_table(alias_name)
+        relation_class = @relation.klass
+        original_table = relation_class.arel_table
+        alias_table = original_table.alias(alias_name)
+
+        where_clause = recursively_alias_table(@relation.where_clause.ast, original_table, alias_table)
+        order_clause = @relation.order_values.map do |order|
+          if order.respond_to?(:expr)
+            order.expr = alias_table[order.expr.name] if order.expr.relation == original_table
+          end
+          order
+        end
+
+        new_relation = @relation.dup.unscope(:select, :where, :order)
+        new_relation.instance_variable_set(:@table, alias_table) # Is there a better way to modify the original relation?
+        new_relation.where(where_clause).order(order_clause)
+      end
+
+      def recursively_alias_table(node, original_table, alias_table)
+        case node
+        when Arel::Nodes::And, Arel::Nodes::Or
+          return nil if node.children.empty?
+
+          # Recurse for left and right nodes
+          node.children.each { |child| recursively_alias_table(child, original_table, alias_table) }
+          node
+        when Arel::Nodes::Grouping
+          # Recurse for the expression inside the grouping
+          node.expr = recursively_alias_table(node.expr, original_table, alias_table)
+          node
+        when Arel::Nodes::Equality, Arel::Nodes::GreaterThan, Arel::Nodes::LessThan, Arel::Nodes::HomogeneousIn
+          # For conditions, modify left-hand side (the column)
+          if node.left.relation == original_table
+            node.left.relation = alias_table
+          end
+          node
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/has_some_of_many/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module HasSomeOfMany
-    VERSION = "1.0.1"
+    VERSION = "1.2.0"
   end
 end

data/lib/activerecord-has_some_of_many.rb

@@ -5,5 +5,7 @@ require_relative "activerecord/has_some_of_many/version"
 
 ActiveSupport.on_load(:active_record) do
   require_relative "activerecord/has_some_of_many/associations"
+  require_relative "activerecord/has_some_of_many/relation_rewriter"
+
   include ActiveRecord::HasSomeOfMany::Associations
 end

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-has_some_of_many
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Ben Sheldon [he/him]
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-31 00:00:00.000000000 Z
+date: 2024-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0.alpha
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0.alpha
+- !ruby/object:Gem::Dependency
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -36,6 +50,7 @@ files:
 - README.md
 - lib/activerecord-has_some_of_many.rb
 - lib/activerecord/has_some_of_many/associations.rb
+- lib/activerecord/has_some_of_many/relation_rewriter.rb
 - lib/activerecord/has_some_of_many/version.rb
 homepage: https://github.com/bensheldon/activerecord-has_some_of_many
 licenses: