activerecord_where_assoc 0.1.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: '0805c22b1a2c499a1d642f4bf4c624e31318192e2243a38ef3dca92cadce2a58'
-  data.tar.gz: bbebf2d6e4402c07a54af54fa87c25c5f94c7813e4b0cc6cc63a761bd291cb7c
+SHA1:
+  metadata.gz: c5feb6230bf9dd2b1e1b8d74443da251e7ae7fbf
+  data.tar.gz: 1917b5b495c2808adf89737ab31676ca99fa5923
 SHA512:
-  metadata.gz: b17588d07e22a79132e62f6341fad4b4e39106ec2b957bed866d85ae3e20c59de95efae7ea1a91cdd812111c40afda385277800a90fc33b95ec14ad5af9f9bdb
-  data.tar.gz: b34651a306ac5503fa96bf30058c00e1b071f9bcb5bc429b249c7455a2d8ec6d6fe6518c95c6060aa507f3fb59bfe44434aba4c5fc0e1ffec6b25c673209e13f
+  metadata.gz: 858c201216236ced5dbc8580874153319f11526849edb21b900302f59aabc7d99d4bd56e35a74c49ef5cd4fe07e8d0b0c4ee092d8fc8cefdcd40f0024dc371ef
+  data.tar.gz: c2ae301a6ad1f8920d33608527db33241c6e6f2bb1f14151cfa8db100af0ad5b24a01debdc46efbbde1268fd4fa7f687b89dce09a147bc8c4f7a174743e8d75a

data/ALTERNATIVES_PROBLEMS.md

@@ -10,9 +10,11 @@ This is a list of some of those alternatives, explaining what issues they have o
 * No more having to choose, case by case, which way has the less problems.  
   Just use `#where_assoc_*` each time and avoid every problems.
 * Need less raw SQL, which means less code, more clarity and less maintenance.
-* Allows powerful scopes without traps.
+* Generates a single `#where`. No weird side-effects things like `#eager_load` or `#join`
+  This makes well-behaved scopes, you can even have multiple conditions on the same association
 * Handles recursive associations correctly.
-* Handles has_one correctly.
+* Handles has_one correctly (Except [MySQL has a limitation](README.md#mysql-doesnt-support-sub-limit)).
+* Handles polymorphic belongs_to
 
 ## Short version
 
@@ -26,6 +28,7 @@ Summary of the problems of the alternatives that `activerecord_where_assoc` solv
   * doing `not exists` with conditions requires a `LEFT JOIN` with the conditions as part of the `ON`, which requires raw SQL.
   * checking for 2 sets of conditions on different records of the same association won't work. (so your scopes can be incompatible)
   * can't be used with Rails 5's `or` unless both sides do the same `joins` / `includes` / `eager_load`.
+  * Doesn't work for polymorphic belongs_to.
 * `joins`:
   * `has_many` may return duplicate records.
   * using `uniq` / `distinct` to solve duplicate rows is an unexpected side-effect when this is in a scope.
@@ -65,6 +68,8 @@ Person.where_assoc_exists(:addresses, city: 'Montreal')
 
 The general version of this problem is the handling of `limit` and `offset` on associations and in default_scopes. where_assoc_exists handle those correctly and only checks the records that match the limit and the offset.
 
+Note: [MySQL has a limitation](README.md#mysql-doesnt-support-sub-limit), this makes handling has_one correctly not possible with MySQL.
+
 ### Raw SQL joins or sub-selects
 
 Having to write the joins and conditions in raw SQL is more painful and more error prone than having a method do it for you. It hides the important details of what you are doing in a lot of verbosity.
@@ -95,6 +100,10 @@ This brings us back to the [raw SQL joins](#raw-sql-joins-or-sub-selects) proble
 
 `where_assoc_*` methods handle this seemlessly.
 
+### Unable to handle polymorphic belongs_to
+
+When you have a polymorphic belongs_to, you can't use `joins` or `includes` in order to do queries on it. You have to use manual SQL ([raw SQL joins](#raw-sql-joins-or-sub-selects)) or a gem that provides the feature, such as `activerecord_where_assoc`.
+
 ## ActiveRecord only
 
 Those are the common ways given in stack overflow answers.
@@ -136,6 +145,7 @@ Post.joins(:comments).where(comments: {is_spam: true})
 * Cannot be used with Rails 5's `or` unless both side do the same `joins`.
 * [Treats has_one like a has_many](#treating-has_one-like-has_many)
 * [Can't handle recursive associations](#unable-to-handle-recursive-associations)
+* [Can't handle polymorphic belongs_to](#unable-to-handle-polymorphic-belongs_to)
 
 ### Using `includes` (or `eager_load`) and `where`
 
@@ -155,6 +165,7 @@ Post.eager_load(:comments).where(comments: {is_spam: true})
 
 * [Treats has_one like a has_many](#treating-has_one-like-has_many)
 * [Can't handle recursive associations](#unable-to-handle-recursive-associations)
+* [Can't handle polymorphic belongs_to](#unable-to-handle-polymorphic-belongs_to)
 
 * Simply cannot be used for complex cases.
 
@@ -180,10 +191,9 @@ This is what is gem does behind the scene, but doing it manually can lead to tro
 
 https://github.com/EugZol/where_exists
 
-An interesting gem that also does `EXISTS (SELECT ... )`behind the scene. Solves most issues from ActiveRecord only alternatives, but appears less powerful than where_assoc_exists.
+An interesting gem that also does `EXISTS (SELECT ... )` behind the scene. Solves most issues from ActiveRecord only alternatives, but appears less powerful than where_assoc_exists.
 
-* where_exists supports polymorphic belongs_to. This is something that where_assoc doesn't do at the moment.  
-  However, the way it does this is by doing a pluck on the type column, which in some situation could be a slow query if there is a lots of rows to scan.
+* where_exists supports polymorphic belongs_to only by always doing a `pluck` everytime. In some situation could be a slow query if there is a lots of rows to scan. where_assoc also allows directly specifying the classes manually, avoiding the pluck and possibly filtering the choices.
   
 * Unable to use scopes of the association's model.
 ```ruby

data/CHANGELOG.md

@@ -1,4 +1,10 @@
 
+# 1.0.0
+
+* Now supports polymorphic belongs_to
+
+# 0.1.3
+
 * Use `SELECT 1` instead of `SELECT 0`...  
   ... it just seems more natural that way.
 * Bugfixes

data/EXAMPLES.md

@@ -2,7 +2,7 @@ Here are some example usages of the gem, along with the generated SQL. Each of t
 
 The models can be found in [examples/models.md](examples/models.md). The comments in that file explain how to get a console to try the queries. There are also example uses of the gem for scopes.
 
-The content of this file is generated from running `ruby examples/examples.rb`
+The content of this file is generated from running `ruby examples/examples.rb > EXAMPLES.md`
 
 -------
 
@@ -50,6 +50,37 @@ SELECT "posts".* FROM "posts"
 
 ---
 
+```ruby
+# Users that have made posts
+User.where_assoc_exists(:posts)
+```
+```sql
+SELECT "users".* FROM "users"
+  WHERE (EXISTS (
+    SELECT 1 FROM "posts"
+    WHERE "posts"."author_id" = "users"."id"
+  ))
+```
+
+---
+
+```ruby
+# Users that have made posts that have comments
+User.where_assoc_exists([:posts, :comments])
+```
+```sql
+SELECT "users".* FROM "users"
+  WHERE (EXISTS (
+    SELECT 1 FROM "posts"
+    WHERE "posts"."author_id" = "users"."id" AND (EXISTS (
+      SELECT 1 FROM "comments"
+      WHERE "comments"."post_id" = "posts"."id"
+    ))
+  ))
+```
+
+---
+
 ## Examples with condition / scope
 
 ```ruby
@@ -170,7 +201,7 @@ SELECT "posts".* FROM "posts"
 ---
 
 ```ruby
-# posts where the author also commented on the post (use conditions between posts)
+# posts where the author also commented on the post (uses a conditions between tables)
 Post.where_assoc_exists(:comments, "posts.author_id = comments.author_id")
 ```
 ```sql

data/README.md

@@ -5,46 +5,45 @@
 [![Code Climate](https://codeclimate.com/github/MaxLap/activerecord_where_assoc/badges/gpa.svg)](https://codeclimate.com/github/MaxLap/activerecord_where_assoc)
 [![Issue Count](https://codeclimate.com/github/MaxLap/activerecord_where_assoc/badges/issue_count.svg)](https://codeclimate.com/github/MaxLap/activerecord_where_assoc)
 
-This gem provides powerful methods to add conditions based on the associations of your records. (Using SQL's `EXISTS` operator)
+This gem makes it easy to do conditions based on the associations of your records in ActiveRecord (Rails). (Using SQL's `EXISTS` operator)
 
 ```ruby
 # Find my_post's comments that were not made by an admin
 my_post.comments.where_assoc_not_exists(:author, is_admin: true).where(...)
  
-# Find posts that have comments by an admin
+# Find every posts that have comments by an admin
 Post.where_assoc_exists([:comments, :author], &:admins).where(...)
  
-# Find my_user's posts that have at least 5 non-spam comments
-my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.where(is_spam: false) }.where(...)
+# Find my_user's posts that have at least 5 non-spam comments (not_spam is a scope on comments)
+my_user.posts.where_assoc_count(5, :>=, :comments) { |comments| comments.not_spam }.where(...)
 ```
 
 These allow for powerful, chainable, clear and easy to reuse queries. (Great for scopes)
 
-You also avoid many [problems with the alternative options](ALTERNATIVES_PROBLEMS.md).
-
-Works with SQLite3, PostgreSQL and MySQL. [MySQL has one limitation](#mysql-doesnt-support-sub-limit). Untested with other RDBMS.
+You avoid many [problems with the alternative options](ALTERNATIVES_PROBLEMS.md).
 
 Here are [many examples](EXAMPLES.md), including the generated SQL queries.
 
-## Feedback
-
-This gem is very new. If you have any feedback, good or bad, do not hesitate to write it here: [General feedback](https://github.com/MaxLap/activerecord_where_assoc/issues/3). If you find any bug, please create a new issue.
-
-* Failure stories, if you had difficulties that kept you from using the gem.
-* Success stories, if you are using it and things are going great, I wanna hear this too.
-* Suggestions to make the documentation easier to follow / more complete.
-
-
-## 0.1
+## Advantages
 
-Since the gem is brand new, I'm releasing as 0.1 before bumping to 1.0 once I have some feedback. There is an extensive test suite testing for lots of cases, making me quite confident that it can handle most of the cases you can throw at it.
+These methods have many advantages over the alternative ways of achieving the similar results:
+* Avoids the [problems with the alternative ways](ALTERNATIVES_PROBLEMS.md)
+* Can be chained and nested with regular ActiveRecord methods (`where`, `merge`, `scope`, etc).
+* Adds a single condition in the `WHERE` of the query instead of complex things like joins.
+  So it's easy to have multiple conditions on the same association
+* Handles `has_one` correctly: only testing the "first" record of the association that matches the default_scope and the scope on the association itself.
+* Handles recursive associations (such as parent/children) seemlessly.
+* Can be used to quickly generate a SQL query that you can edit/use manually.
 
 ## Installation
 
+Rails 4.1 to 6.0 are supported with Ruby 2.1 to 2.6.  
+Works with SQLite3, PostgreSQL and MySQL. Untested with other RDBMS.
+
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'activerecord_where_assoc'
+gem 'activerecord_where_assoc', '~> 1.0'
 ```
 
 And then execute:
@@ -57,112 +56,53 @@ Or install it yourself as:
 
 ## Usage
 
-### `#where_assoc_exists` & `#where_assoc_not_exists`
-
-Returns a new relation, which is the result of filtering the current relation based on if a record for the specified association of the model exists (or not). Conditions that the associated model must match to count as existing can also be specified.
-
-```ruby
-Post.where_assoc_exists(:comments, is_spam: true)
-Post.where_assoc_not_exists(:comments, is_spam: true)
-```
-
-* 1st parameter: the association we are doing the condition on.
-* 2nd parameter: (optional) the condition to apply on the association. It can be anything that `#where` can receive, so: Hash, String and Array (string with binds).
-* 3rd parameter: [options (listed below)](#options) to alter some behaviors. (rarely necessary)
-* block: adds more complex conditions by receiving a relation on the association. Can apply `#where`, `#where_assoc_*`, scopes, and other scoping methods.
-  The block either:
-
-  * receives no argument, in which case `self` is set to the relation, so you can do `{ where(id: 123) }`
-  * receives arguments, in which case the block is called with the relation as first parameter
-
-  The block should return the new relation to use or `nil` to do as if there were no blocks
-  It's common to use `where_assoc_*(..., &:scope_name)` to apply a single scope quickly
-
-### `#where_assoc_count`
-
-This is a generalization of `#where_assoc_exists` and `#where_assoc_not_exists`. It behaves the same way as them, but is more flexible as it allows you to be specific about how many matches there should be. To clarify, here are equivalent examples:
-
-```ruby
-Post.where_assoc_exists(:comments, is_spam: true)
-Post.where_assoc_count(1, :<=, :comments, is_spam: true)
-
-Post.where_assoc_not_exists(:comments, is_spam: true)
-Post.where_assoc_count(0, :==, :comments, is_spam: true)
-```
-
-* 1st parameter: the left side of the comparison. One of:  
-  * a number  
-  * a string of SQL to embed in the query  
-  * a range (operator must be `:==` or `:!=`)  
-    will use SQL's `BETWEEN` or `NOT BETWEEN`  
-    supports infinite ranges and exclusive end
-* 2nd parameter: the operator to use: `:<`, `:<=`, `:==`, `:!=`, `:>=`, `:>`
-* 3rd, 4th, 5th parameters are the same as the 1st, 2nd and 3rd parameters of `#where_assoc_exists`.
-* block: same as `#where_assoc_exists`' block
+The [documentation is nicely structured](https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/QueryMethods.html)  
+You can view [many examples](EXAMPLES.md).
 
-The order of the parameters may seem confusing, but you will get used to it. To help remember the order of the parameters, remember that the goal is to do:
+Otherwise, here is a short explanation:
 
-    5 < (SELECT COUNT(*) FROM ...)
-
-The parameters are in the same order as in that query: number, operator, association.
-
-### More examples
-
-You can view [more usage examples](EXAMPLES.md).
-
-### Options
-
-Each of the methods above can take an options argument. It is also possible to change the default value for the options.
-
-* On a per-call basis:
-```ruby
-# Options are passed after the conditions argument
-Posts.where_assoc_exists(:last_status, nil, ignore_limit: true)
-Posts.where_assoc_count(1, :<, :last_status, nil, ignore_limit: true)
-```
-
-* As default for everywhere
 ```ruby
-# Somewhere in your setup code, such as an initializer in Rails
-ActiveRecordWhereAssoc.default_options[:ignore_limit] = true
+where_assoc_exists(association_name, conditions, options, &block)
+where_assoc_not_exists(association_name, conditions, options, &block)
+where_assoc_count(left_operand, operator, association_name, conditions, options, &block)
 ```
 
-Here is a list of the available options:
-
-#### :ignore_limit
-
-When this option is true, then `#limit` and `#offset` that are set either from default_scope or on associations are ignored. `#has_one` means `limit(1)`, so `#has_one` will behave like `#has_many` with this option.
-
-Main reasons to use this:
-* This is needed for MySQL to be able to do anything with `#has_one` associations because [MySQL doesn't support sub-limit](#mysql-doesnt-support-sub-limit).
-* You have a `#has_one` association which you know can never have more than one record. Using `:ignore_limit`, you will use the simpler query of `#has_many`, which can be more efficient.
-
-Why this isn't the default:
-* From very few tests, the aliasing way seems to produce better plans.
-* Using aliasing produces a shorter query.
-
-#### :never_alias_limit
-
-When this option is true, `#where_assoc_*` will not use `#from` to build relations that have `#limit` or `#offset` set on default_scope or on associations. Note, `#has_one` means `limit(1)`, so it will also use `#from` unless this option is activated.
-
-Main reasons to use this:
-* You have to use `#from` as condition for `#where_assoc_*` method (possibly because a scope needs it).
-* This might result in a difference execution plan for the query since the query ends up being quite different.
-
-## Supported Rails versions
-
-Rails 4.1 to 5.2 are supported with Ruby 2.1 to 2.5.
-
-## Advantages
-
-These methods have many advantages over the alternative ways of achieving the similar results:
-* Avoids the [problems with the alternative ways](ALTERNATIVES_PROBLEMS.md)
-* Can be chained and nested with regular ActiveRecord methods (`where`, `merge`, `scope`, etc).
-* Adds a single condition in the `WHERE` of the query instead of complex things like joins.
-  * So it's easy to have multiple conditions on the same association
-* Handles `has_one` correctly: only testing the "first" record of the association that matches the default_scope and the scope on the association itself.
-* Handles recursive associations (such as parent/children) seemlessly.
-* Can be used to quickly generate a SQL query that you can edit/use manually.
+* These methods add a condition (a `#where`) to the relation that checks if the association exists (or not)  
+* You can specify condition on the association, so you could check only comments that are made by an admin.  
+* Each method returns a new relation, meaning you can chain `#where`, `#order`, `limit`, etc.  
+* common arguments:
+  * association_name: the association we are doing the condition on.
+  * conditions: (optional) the condition to apply on the association. It can be anything that `#where` can receive, so: Hash, String and Array (string with binds).
+  * options: [available options](https://maxlap.github.io/activerecord_where_assoc/ActiveRecordWhereAssoc/QueryMethods#module-ActiveRecordWhereAssoc::QueryMethods-label-Options) to alter some behaviors. (rarely necessary)
+  * block: adds more complex conditions by receiving a relation on the association. Can use `#where`, `#where_assoc_*`, scopes, and other scoping methods.  
+    Must return a relation.
+    The block either:
+    * receives no argument, in which case `self` is set to the relation, so you can do `{ where(id: 123) }`
+    * receives arguments, in which case the block is called with the relation as first parameter.
+
+    The block should return the new relation to use or `nil` to do as if there were no blocks.  
+    It's common to use `where_assoc_*(..., &:scope_name)` to use a single scope.
+* `#where_assoc_count` is a generalization of `#where_assoc_exists` and `#where_assoc_not_exists`. It behaves the same way, but is more powerful, as it allows you to specify how many matches there should be.
+    ```ruby
+    # These are equivalent:
+    Post.where_assoc_exists(:comments, is_spam: true)
+    Post.where_assoc_count(1, :<=, :comments, is_spam: true)
+
+    Post.where_assoc_not_exists(:comments, is_spam: true)
+    Post.where_assoc_count(0, :==, :comments, is_spam: true)
+
+    # This has no equivalent (Posts with at least 5 spam comments)
+    Post.where_assoc_count(5, :<=, :comments, is_spam: true)
+    ```
+* `where_assoc_count`'s additional arguments  
+  The order of the parameters of `#where_assoc_count` can be confusingof may seem confusing, but you will get used to it. To help remember: the goal is to do: `5 < (SELECT COUNT(*) FROM ...)`, the number is first, then operator, then the association and its conditions.
+  * left_operand:  
+      * a number  
+      * a string of SQL to embed in the query  
+      * a range (operator must be `:==` or `:!=`)  
+        will use SQL's `BETWEEN` or `NOT BETWEEN`  
+        supports infinite ranges and exclusive end
+  * operator: one of `:<`, `:<=`, `:==`, `:!=`, `:>=`, `:>`
 
 ## Usage tips
 
@@ -225,7 +165,7 @@ Doing the same thing but with less associations between `address` and `posts` wo
 
 ### The opposite of multiple nested EXISTS...
 
-... is a single `NOT EXISTS` with then nested ones still using `EXISTS`.
+... is a single `NOT EXISTS` with the nested ones still using `EXISTS`.
 
 All the methods always chain nested associations using an `EXISTS` when they have to go through multiple hoops. Only the outer-most, or first, association will have a `NOT EXISTS` when using `#where_assoc_not_exists` or a `COUNT` when using `#where_assoc_count`. This is the logical way of doing it.
 
@@ -255,7 +195,7 @@ Note that the support of `#limit` and `#offset` for the `:source` and `:through`
 
 After checking out the repo, run `bundle install` to install dependencies.
 
-Run `rake test` to run the tests for the latest version of rails
+Run `rake test` to run the tests for the latest version of rails. If you want SQL queries printed when you have failures, use `SQL_WITH_FAILURES=1 rake test`.
 
 Run `bin/console` for an interactive prompt that will allow you to experiment in the same environment as the tests.
 

data/lib/active_record_where_assoc.rb

@@ -4,11 +4,20 @@ 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[:ignore_limit] = true
+  #
+  # A description for each can be found in ActiveRecordWhereAssoc::QueryMethods#where_assoc_exists.
+  #
+  # The only one that truly makes sense to change is :ignore_limit, when you are using MySQL, since
+  # limit are never supported on it.
   def self.default_options
     @default_options ||= {
                            ignore_limit: false,
                            never_alias_limit: false,
+                           poly_belongs_to: :raise,
                          }
   end
 end

data/lib/active_record_where_assoc/active_record_compat.rb

@@ -3,22 +3,24 @@
 module ActiveRecordWhereAssoc
   module ActiveRecordCompat
     if ActiveRecord.gem_version >= Gem::Version.new("5.1")
-      def self.join_keys(reflection)
-        reflection.join_keys
+      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 +33,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 +71,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