activerecord-has_some_of_many 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a519b095203661135d0889d1679af1641796fd1ad08f22ef7c98018a907e700b
-  data.tar.gz: 6619a47edd047b8fe5bbc4c8c1ecc7c1c8b0b0d4d97f5230019104e1f359f290
+  metadata.gz: f35b023998c92a01d9614640c84f296ac53c15ba1459daec41da6fc042b7ff8c
+  data.tar.gz: d004c4ce3f54eea253f86a0347d5690693b220e9f364e9c36037df91502c021e
 SHA512:
-  metadata.gz: 166385a50777f3b578a0d14d880ccd878510545942cab07208cc8ca5f7ab88a86e448df460d591d90d2e2afd68f8de8b776b079b965052d12b51526753ae9aa3
-  data.tar.gz: 3d76b0b5882c2baa1c597fc69fdb6a302b56c011433d8e6df370f220d1280d1f42bc18186c8fec388d3f0819d60eeec108793e2118831d6dc6738013fb0e43bf
+  metadata.gz: 52201a2fb0479d35037a324178434820f87eb3b527733e9d7ce797153b50bc8160fe01a38c8fbe698f86bb9728054b8a1a73030f500436586236d10c6d3a3841
+  data.tar.gz: b827a9092bd4d422c367b61afca9cd0d3edbe70738c9b7a49db1de6848e3c0c9a55d4c187b817389ea03d332a91f9536b1d1de78b7ba96ec327c86fdd6a891b7

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.0"
+    VERSION = "1.1.0"
   end
 end

data/lib/activerecord-has_some_of_many.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 require 'active_support/lazy_load_hooks'
-require_relative "version"
+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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-has_some_of_many
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.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-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -36,6 +36,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: