where_exists 1.2.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10aa100274a4f1cbc5ffd1efddaf255242a4ffa99bb4aa857ec807e4060a2198
-  data.tar.gz: 7572426b34fd9056a781006dce704de782bc94f48899ec66d6cdb2ce7fd00aab
+  metadata.gz: d9957b5787ab2fda2505560b01ffeca8f2e1d24bf0d0d38e09f4f25969a30ab6
+  data.tar.gz: 4718917be7477f54afb0e322a588adadb4d2d375c6b7938d922b89ef0629ea27
 SHA512:
-  metadata.gz: d17add3cb16b2edeca33761dd8097b4da1f1203af9ffe891b0c2756d6e606b08b12ac7ce67bd8e5869cfee6389fbfc8fcb26da2d00941d00ab9c00d6691c8af9
-  data.tar.gz: 33f4b910af735aedb797329d99c876a5978fdaac103f704044ad9095e4856e4cffc17359f5f2ad0c4f21379483622f25fecd842a4928327e2641d21078cee77c
+  metadata.gz: 839de9969500c67df98512ee5f5043b4d34a8e337263e3dcc79dd081e6730a0b1bb6bce3c632a764372d6dabe143f9b3c7ffcbc55092f55727d8746d40eafaf3
+  data.tar.gz: a4c38490f6caf945889d2f92075e1069cef92706524c299bd4d800c4b856fd62fda39738539fee816daa955a5ef3908e49c7aed9ed4e3be97af6bf8c419f3b07

data/README.markdown

@@ -0,0 +1,174 @@
+# Where Exists
+**Rails way to harness the power of SQL EXISTS condition**<br>
+[![Gem Version](https://badge.fury.io/rb/where_exists.svg)](http://badge.fury.io/rb/where_exists)
+
+## Description
+
+<img src="exists.png" alt="Exists" align="right" width="100" height="200">
+
+This gem does exactly two things:
+
+* Selects each model object for which there is a certain associated object
+* Selects each model object for which there aren't any certain associated objects
+
+It uses SQL [EXISTS condition](http://www.techonthenet.com/sql/exists.php) to do it fast, and extends ActiveRecord with `where_exists` and `where_not_exists` methods to make its usage simple and straightforward.
+
+## Quick start
+
+Add gem to Gemfile:
+
+    gem 'where_exists'
+
+and run `bundle install` as usual.
+
+And now you have `where_exists` and `where_not_exists` methods available for your ActiveRecord models and relations.
+
+Syntax:
+
+```ruby
+Model.where_exists(association, additional_finder_parameters)
+```
+
+Supported Rails versions: >= 5.2.
+
+## Example of usage
+
+Given there is User model:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :connections
+  has_many :groups, through: :connections
+end
+```
+
+And Group:
+
+```ruby
+class Group < ActiveRecord::Base
+  has_many :connections
+  has_many :users, through: :connections
+end
+```
+
+And standard many-to-many Connection:
+
+```ruby
+class Connection
+  belongs_to :user
+  belongs_to :group
+end
+```
+
+What I want to do is to:
+
+* Select users who don't belong to given set of Groups (groups with ids `[4,5,6]`)
+* Select users who belong to one set of Groups (`[1,2,3]`) and don't belong to another (`[4,5,6]`)
+* Select users who don't belong to a Group
+
+Also, I don't want to:
+
+* Fetch a lot of data from database to manipulate it with Ruby code. I know that will be inefficient in terms of CPU and memory (Ruby is much slower than any commonly used DB engine, and typically I want to rely on DB engine to do the heavy lifting)
+* I tried queries like `User.joins(:group).where(group_id: [1,2,3]).where.not(group_id: [4,5,6])` and they return wrong results (some users from the result set belong to groups 4,5,6 *as well as* 1,2,3)
+* I don't want to do `join` merely for the sake of only checking for existence, because I know that that is a pretty complex (i.e. CPU/memory-intensive) operation for DB
+
+<sub><sup>If you wonder how to do that without the gem (i.e. essentially by writing SQL EXISTS statement manually) see that [StackOverflow answer](http://stackoverflow.com/a/32016347/5029266) (disclosure: it's self-answered question of a contributor of this gem).</sup></sub>
+
+And now you are able to do all these things (and more) as simple as:
+
+> Select only users who don't belong to given set of Groups (groups with ids `[4,5,6]`)
+
+```ruby
+# It's really neat, isn't it?
+User.where_exists(:groups, id: [4,5,6])
+```
+
+<sub><sup>Notice that the second argument is `where` parameters for Group model</sup></sub>
+
+> Select only users who belong to one set of Groups (`[1,2,3]`) and don't belong to another (`[4,5,6]`)
+
+```ruby
+# Chain-able like you expect them to be.
+#
+# Additional finder parameters is anything that
+# could be fed to 'where' method.
+#
+# Let's use 'name' instead of 'id' here, for example.
+
+User.where_exists(:groups, name: ['first','second','third']).
+  where_not_exists(:groups, name: ['fourth','fifth','sixth'])
+```
+
+<sub><sup>It is possible to add as much attributes to the criteria as it is necessary, just as with regular `where(...)`</sub></sup>
+
+> Select only users who don't belong to a Group
+
+```ruby
+# And that's just its basic capabilities
+User.where_not_exists(:groups)
+```
+
+<sub><sup>Adding parameters (the second argument) to `where_not_exists` method is feasible as well, if you have such requirements.</sup></sub>
+
+
+> Re-use existing scopes
+
+```ruby
+User.where_exists(:groups) do |groups_scope|
+  groups_scope.activated_since(Time.now)
+end
+
+User.where_exists(:groups, &:approved)
+```
+<sub><sup>If you pass a block to `where_exists`, the scope of the relation will be yielded to your block so you can re-use existing scopes.</sup></sub>
+
+
+
+## Additional capabilities
+
+**Q**: Does it support both `has_many` and `belongs_to` association type?<br>
+**A**: Yes.
+
+
+**Q**: Does it support polymorphic associations?<br>
+**A**: Yes, both ways.
+
+
+**Q**: Does it support multi-level (recursive) `:through` associations?<br>
+**A**: You bet. (Now you can forget complex EXISTS or JOIN statetements in a pretty wide variety of similar cases.)
+
+
+**Q**: Does it support `where` parameters with interpolation, e.g. `parent.where_exists(:child, 'fieldA > ?', 1)`?<br>
+**A**: Yes.
+
+
+**Q**: Does it take into account default association condition, e.g. `has_many :drafts, -> { where published: nil }`?<br>
+**A**: Yes.
+
+## Contributing
+
+If you find that this gem lacks certain possibilities that you would have found useful, don't hesitate to create a [feature request](https://github.com/EugZol/where_exists/issues).
+
+Also,
+
+* Report bugs
+* Submit pull request with new features or bug fixes
+* Enhance or clarify the documentation that you are reading
+
+**Please ping me in addition to creating PR/issue** (just add "@EugZol" to the PR/issue text). Thank you!
+
+To run tests:
+```
+> bundle exec appraisal install
+> bundle exec appraisal rake test
+```
+
+## License
+
+This project uses MIT license. See [`MIT-LICENSE`](https://github.com/EugZol/where_exists/blob/master/MIT-LICENSE) file for full text.
+
+## Alternatives
+
+One known alternative is https://github.com/MaxLap/activerecord_where_assoc
+
+A comprehensive comparison is made by MaxLap here: https://github.com/MaxLap/activerecord_where_assoc/blob/master/ALTERNATIVES_PROBLEMS.md

data/lib/where_exists/version.rb

@@ -1,3 +1,3 @@
 module WhereExists
-  VERSION = "1.2.1"
+  VERSION = "2.0.2"
 end

data/lib/where_exists.rb

@@ -20,7 +20,11 @@ module WhereExists
       not_string = "NOT "
     end
 
-    self.where("#{not_string}(#{queries_sql})")
+    if queries_sql.empty?
+      does_exist ? self.none : self.all
+    else
+      self.where("#{not_string}(#{queries_sql})")
+    end
   end
 
   def build_exists_string(association_name, *where_parameters, &block)
@@ -32,11 +36,11 @@ module WhereExists
 
     case association.macro
     when :belongs_to
-      queries = where_exists_for_belongs_to_query(association, where_parameters)
+      queries = where_exists_for_belongs_to_query(association, where_parameters, &block)
     when :has_many, :has_one
-      queries = where_exists_for_has_many_query(association, where_parameters)
+      queries = where_exists_for_has_many_query(association, where_parameters, &block)
     when :has_and_belongs_to_many
-      queries = where_exists_for_habtm_query(association, where_parameters)
+      queries = where_exists_for_habtm_query(association, where_parameters, &block)
     else
       inspection = nil
       begin
@@ -49,13 +53,12 @@ module WhereExists
 
     queries_sql =
       queries.map do |query|
-        query = yield query if block_given?
         "EXISTS (" + query.to_sql + ")"
       end
     queries_sql.join(" OR ")
   end
 
-  def where_exists_for_belongs_to_query(association, where_parameters)
+  def where_exists_for_belongs_to_query(association, where_parameters, &block)
     polymorphic = association.options[:polymorphic].present?
 
     association_scope = association.scope
@@ -89,13 +92,14 @@ module WhereExists
 
         query = query.where("#{self_type} IN (?)", other_types.uniq)
       end
+      query = yield query if block_given?
       queries.push query
     end
 
     queries
   end
 
-  def where_exists_for_has_many_query(association, where_parameters, next_association = {})
+  def where_exists_for_has_many_query(association, where_parameters, next_association = {}, &block)
     if association.through_reflection
       raise ArgumentError.new(association) unless association.source_reflection
       next_association = {
@@ -107,9 +111,9 @@ module WhereExists
 
       case association.macro
       when :has_many, :has_one
-        return where_exists_for_has_many_query(association, {}, next_association)
+        return where_exists_for_has_many_query(association, {}, next_association, &block)
       when :has_and_belongs_to_many
-        return where_exists_for_habtm_query(association, {}, next_association)
+        return where_exists_for_habtm_query(association, {}, next_association, &block)
       else
         inspection = nil
         begin
@@ -144,17 +148,18 @@ module WhereExists
     end
 
     if next_association[:association]
-      return loop_nested_association(result, next_association)
+      return loop_nested_association(result, next_association, &block)
     end
 
     if where_parameters != []
       result = result.where(*where_parameters)
     end
 
+    result = yield result if block_given?
     [result]
   end
 
-  def where_exists_for_habtm_query(association, where_parameters, next_association = {})
+  def where_exists_for_habtm_query(association, where_parameters, next_association = {}, &block)
     association_scope = association.scope
 
     associated_model = association.klass
@@ -178,7 +183,7 @@ module WhereExists
       where("#{join_ids} = #{self_ids}")
 
     if next_association[:association]
-      return loop_nested_association(result, next_association)
+      return loop_nested_association(result, next_association, &block)
     end
 
     if where_parameters != []
@@ -189,15 +194,18 @@ module WhereExists
       result = result.instance_exec(&association_scope)
     end
 
+    result = yield result if block_given?
+
     [result]
   end
 
-  def loop_nested_association(query, next_association = {}, nested = false)
+  def loop_nested_association(query, next_association = {}, nested = false, &block)
     str = query.klass.build_exists_string(
       next_association[:association].name,
       *[
         *next_association[:params]
       ],
+      &block
     )
 
     if next_association[:next_association] && next_association[:next_association][:association]
@@ -206,7 +214,8 @@ module WhereExists
         "(#{subq} AND (#{loop_nested_association(
           next_association[:association],
           next_association[:next_association],
-          true
+          true,
+          &block
         )}))"
       end
     end

data/test/belongs_to_polymorphic_test.rb

@@ -61,6 +61,18 @@ class BelongsToPolymorphicTest < Minitest::Test
     assert_equal orphaned_child.id, result.first.id
   end
 
+  def test_no_entities_or_empty_child_relation
+    result = BelongsToPolymorphicChild.where_not_exists(:polymorphic_entity)
+    assert_equal 0, result.length
+
+    _first_child = BelongsToPolymorphicChild.create!
+    result = BelongsToPolymorphicChild.where_not_exists(:polymorphic_entity)
+    assert_equal 1, result.length
+
+    result = BelongsToPolymorphicChild.where_exists(:polymorphic_entity)
+    assert_equal 0, result.length
+  end
+
   def test_table_name_based_lookup
     first_entity = FirstPolymorphicEntity.create!
     second_entity = SecondPolymorphicEntity.create! id: first_entity.id + 1

data/test/has_many_through_test.rb

@@ -52,8 +52,6 @@ class Blob < ActiveRecord::Base
   end
 end
 
-
-
 class Project < ActiveRecord::Base
   has_many :tasks
   has_many :invoices, :through => :tasks
@@ -99,8 +97,6 @@ class HasManyThroughTest < Minitest::Test
   end
 
   def test_one_level_through
-    ActiveRecord::Base.descendants.each(&:delete_all)
-
     project = Project.create!
     irrelevant_project = Project.create!
 
@@ -121,8 +117,6 @@ class HasManyThroughTest < Minitest::Test
   end
 
   def test_deep_through
-    ActiveRecord::Base.descendants.each(&:delete_all)
-
     project = Project.create! name: 'relevant'
     irrelevant_project = Project.create! name: 'irrelevant'
 
@@ -188,6 +182,14 @@ class HasManyThroughTest < Minitest::Test
     result = Project.where_not_exists(:blobs)
 
     assert_equal 0, result.length
+  end
 
+  def test_with_yield
+    project = Project.create! name: 'example_project'
+    task = Task.create!(project: project)
+    line_item = LineItem.create!(name: 'example_line_item', task: task)
+    result = Project.where_exists(:project_line_items) { |scope| scope.where(name: 'example_line_item') }
+
+    assert_equal 1, result.length
   end
 end

metadata

@@ -1,49 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: where_exists
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
+date: 2022-10-31 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: '4.2'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6.1'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -86,6 +86,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rails way to harness the power of SQL "EXISTS" statement
 email:
 - eugzol@gmail.com
@@ -94,12 +108,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
+- README.markdown
 - Rakefile
 - lib/where_exists.rb
 - lib/where_exists/version.rb
 - test/belongs_to_polymorphic_test.rb
 - test/belongs_to_test.rb
-- test/db/test.db
 - test/documentation_test.rb
 - test/has_and_belongs_to_many.rb
 - test/has_many_polymorphic_test.rb
@@ -125,17 +139,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.2
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: "#where_exists extension of ActiveRecord"
 test_files:
+- test/documentation_test.rb
 - test/belongs_to_polymorphic_test.rb
 - test/belongs_to_test.rb
-- test/db/test.db
-- test/documentation_test.rb
-- test/has_and_belongs_to_many.rb
 - test/has_many_polymorphic_test.rb
-- test/has_many_test.rb
 - test/has_many_through_test.rb
 - test/test_helper.rb
+- test/has_and_belongs_to_many.rb
+- test/has_many_test.rb