where_exists 1.1.3 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 053b8ce3825e7f5eeb8faa98a85d5e2fc92c4edf
-  data.tar.gz: 4aefc7de26143e6b72b62f99113fea19f6737b2e
+SHA256:
+  metadata.gz: 28bde73cd6a1857a0762a1fd489258ad40b44cea344afba4357cbe7fa83cdf41
+  data.tar.gz: ed7a98cb6a7391cb955c911f0063f9eb901e86305b0b7ddb3e01b9a209371476
 SHA512:
-  metadata.gz: e3b5343d68abd33b091752e49c4689215655e515d785052478022bd33f743d621e196c1bbab623a57d67db1e46bcc3ea3a8949b4170955b09674b371f389b5fa
-  data.tar.gz: 166df723c753b0b755eb46b51c9f4acac4f795ac887fb2d1d9ed18ec27ee76b78c783d5f32d8d1fbf29e70ac2a7589b0e4877fd6c02deb1315fddb5925c70226
+  metadata.gz: 943e345289ac9f2a2d44a5428a559c8a22adb11713b26ac0e7893fd28ccbb9577a092bbae50fa9eec960c72497ca5d902892209ce7c83d9c2b291fc017e0d5ab
+  data.tar.gz: 509c56167e4998c662bf21efa637de8495cc5d2974421041d8264f66de16f99a2c223463cfd494b35f64bffb39b8511696822405e2609b649ff876f685ffd4cc

data/README.markdown

@@ -0,0 +1,168 @@
+# 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="http://i.imgur.com/psLfPoW.gif" 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: >= 4.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
+
+To run tests: `bundle exec 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.rb

@@ -47,10 +47,12 @@ module WhereExists
       raise ArgumentError.new("where_exists: not supported association – #{inspection}")
     end
 
-    queries_sql = queries.map { |query|
-      query = yield query if block_given?
-      "EXISTS (" + query.to_sql + ")"
-    }.join(" OR ")
+    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)
@@ -59,7 +61,9 @@ module WhereExists
     association_scope = association.scope
 
     if polymorphic
-      associated_models = self.select("DISTINCT #{connection.quote_column_name(association.foreign_type)}").pluck(association.foreign_type).map(&:constantize)
+      associated_models = self.select("DISTINCT #{connection.quote_column_name(association.foreign_type)}").
+        where("#{connection.quote_column_name(association.foreign_type)} IS NOT NULL").pluck(association.foreign_type).
+        uniq.map(&:classify).map(&:constantize)
     else
       associated_models = [association.klass]
     end
@@ -80,8 +84,10 @@ module WhereExists
         query = query.instance_exec(&association_scope)
       end
       if polymorphic
-        other_type = connection.quote(associated_model.name)
-        query = query.where("#{self_type} = #{other_type}")
+        other_types = [associated_model.name, associated_model.table_name]
+        other_types << associated_model.polymorphic_name if associated_model.respond_to?(:polymorphic_name)
+
+        query = query.where("#{self_type} IN (?)", other_types.uniq)
       end
       queries.push query
     end
@@ -127,8 +133,14 @@ module WhereExists
 
     if association.options[:as]
       other_types = quote_table_and_column_name(associated_model.table_name, association.type)
-      self_class = connection.quote(self.name)
-      result = result.where("#{other_types} = #{self_class}")
+      class_values = [self.name, self.table_name]
+      class_values << self.polymorphic_name if associated_model.respond_to?(:polymorphic_name)
+
+      result = result.where("#{other_types} IN (?)", class_values.uniq)
+    end
+
+    if association_scope
+      result = result.instance_exec(&association_scope)
     end
 
     if next_association[:association]
@@ -139,10 +151,6 @@ module WhereExists
       result = result.where(*where_parameters)
     end
 
-    if association_scope
-      result = result.instance_exec(&association_scope)
-    end
-
     [result]
   end
 
@@ -153,11 +161,9 @@ module WhereExists
 
     primary_key = association.options[:primary_key] || self.primary_key
 
-    join_table = [self.table_name, associated_model.table_name].sort.join("_")
-
     self_ids = quote_table_and_column_name(self.table_name, primary_key)
-    join_ids = quote_table_and_column_name(join_table, association.foreign_key)
-    associated_join_ids = quote_table_and_column_name(join_table, "#{associated_model.name.downcase}_id")
+    join_ids = quote_table_and_column_name(association.join_table, association.foreign_key)
+    associated_join_ids = quote_table_and_column_name(association.join_table, association.association_foreign_key)
     associated_ids = quote_table_and_column_name(associated_model.table_name, associated_model.primary_key)
 
     result =
@@ -165,7 +171,7 @@ module WhereExists
       select("1").
       joins(
         <<-SQL
-          INNER JOIN #{connection.quote_table_name(join_table)}
+          INNER JOIN #{connection.quote_table_name(association.join_table)}
           ON #{associated_ids} = #{associated_join_ids}
         SQL
       ).
@@ -196,13 +202,13 @@ module WhereExists
 
     if next_association[:next_association] && next_association[:next_association][:association]
       subq = str.match(/\([^\(\)]+\)/mi)[0]
-      str.sub!(subq,
+      str.sub!(subq) do
         "(#{subq} AND (#{loop_nested_association(
           next_association[:association],
           next_association[:next_association],
           true
         )}))"
-      )
+      end
     end
 
     nested ? str : [query.where(str)]

data/lib/where_exists/version.rb

@@ -1,3 +1,3 @@
 module WhereExists
-  VERSION = "1.1.3"
+  VERSION = "1.2.2"
 end

data/test/belongs_to_polymorphic_test.rb

@@ -60,4 +60,21 @@ class BelongsToPolymorphicTest < Minitest::Test
     assert_equal 1, result.length
     assert_equal orphaned_child.id, result.first.id
   end
+
+  def test_table_name_based_lookup
+    first_entity = FirstPolymorphicEntity.create!
+    second_entity = SecondPolymorphicEntity.create! id: first_entity.id + 1
+
+    first_child = BelongsToPolymorphicChild.create!(polymorphic_entity_id: first_entity.id, polymorphic_entity_type: first_entity.class.table_name)
+    second_child = BelongsToPolymorphicChild.create!(polymorphic_entity_id: second_entity.id, polymorphic_entity_type: second_entity.class.table_name)
+    orphaned_child = BelongsToPolymorphicChild.create!(polymorphic_entity_id: second_entity.id, polymorphic_entity_type: first_entity.class.table_name)
+
+    result = BelongsToPolymorphicChild.where_exists(:polymorphic_entity)
+    assert_equal 2, result.length
+    assert_equal [first_child, second_child].map(&:id).sort, result.map(&:id).sort
+
+    result = BelongsToPolymorphicChild.where_not_exists(:polymorphic_entity)
+    assert_equal 1, result.length
+    assert_equal [orphaned_child].map(&:id).sort, result.map(&:id).sort
+  end
 end

data/test/has_many_polymorphic_test.rb

@@ -35,10 +35,17 @@ class HasManyPolymorphicTest < Minitest::Test
     child = HasManyPolymorphicChild.create!
 
     irrelevant_entity = IrrelevantPolymorphicEntity.create!(children: [child])
-    _relevant_entity = RelevantPolymorphicEntity.create!(id: irrelevant_entity.id)
+    relevant_entity = RelevantPolymorphicEntity.create!(id: irrelevant_entity.id)
+
+    assert_equal 0, RelevantPolymorphicEntity.where_exists(:children).length
+    assert_equal 1, IrrelevantPolymorphicEntity.where_exists(:children).length
+
+    child.update!(polymorphic_thing_type: RelevantPolymorphicEntity.table_name)
 
     result = RelevantPolymorphicEntity.where_exists(:children)
 
-    assert_equal 0, result.length
+    assert_equal 0, IrrelevantPolymorphicEntity.where_exists(:children).length
+    assert_equal 1, result.length
+    assert_equal relevant_entity.id, result.first&.id
   end
 end

data/test/has_many_through_test.rb

@@ -1,34 +1,71 @@
 require_relative 'test_helper'
 
-ActiveRecord::Migration.create_table :projects, :force => true do |t|
+ActiveRecord::Migration.create_table :projects, force: true do |t|
   t.string :name
 end
 
-ActiveRecord::Migration.create_table :tasks, :force => true do |t|
+ActiveRecord::Migration.create_table :tasks, force: true do |t|
   t.string :name
   t.integer :project_id
 end
 
-ActiveRecord::Migration.create_table :line_items, :force => true do |t|
+ActiveRecord::Migration.create_table :line_items, force: true do |t|
   t.string :name
   t.integer :invoice_id
   t.integer :task_id
 end
 
-ActiveRecord::Migration.create_table :work_details, :force => true do |t|
+ActiveRecord::Migration.create_table :work_details, force: true do |t|
   t.string :name
   t.integer :line_item_id
 end
 
-ActiveRecord::Migration.create_table :invoices, :force => true do |t|
+ActiveRecord::Migration.create_table :invoices, force: true do |t|
   t.string :name
 end
 
+ActiveRecord::Migration.create_table :blobs, force: true  do |t|
+end
+
+ActiveRecord::Migration.create_table :attachments, force: true  do |t|
+  t.string     :name,     null: false
+  t.references :record,   null: false, polymorphic: true, index: false
+  t.references :blob,     null: false
+
+  t.datetime :created_at, null: false
+
+  t.index [ :record_type, :record_id, :name, :blob_id ], name: "index_attachments_uniqueness", unique: true
+end
+
+class Attachment < ActiveRecord::Base
+  belongs_to :record, polymorphic: true, touch: true
+  belongs_to :blob
+end
+
+class Blob < ActiveRecord::Base
+  has_many :attachments
+
+  scope :unattached, -> { left_joins(:attachments).where(Attachment.table_name => { blob_id: nil }) }
+
+  before_destroy(prepend: true) do
+    raise ActiveRecord::InvalidForeignKey if attachments.exists?
+  end
+end
+
+
+
 class Project < ActiveRecord::Base
   has_many :tasks
   has_many :invoices, :through => :tasks
   has_many :project_line_items, :through => :tasks, :source => :line_items
   has_many :work_details, :through => :project_line_items
+
+  has_many :attachments, as: :record
+  has_many :blobs, through: :attachments, source: :blob
+  has_many :relevant_attachments, -> { where(name: "relevant") }, as: :record, class_name: "Attachment", inverse_of: :record, dependent: false
+  has_many :relevant_blobs, through: :relevant_attachments, class_name: "Blob", source: :blob
+  has_many :irrelevant_attachments, -> { where(name: "irrelevant") }, as: :record, class_name: "Attachment", inverse_of: :record, dependent: false
+  has_many :irrelevant_blobs, through: :irrelevant_attachments, class_name: "Blob", source: :blob
 end
 
 class Task < ActiveRecord::Base
@@ -36,6 +73,7 @@ class Task < ActiveRecord::Base
 
   has_many :invoices, :through => :line_items
   has_many :line_items
+  has_many :scoped_line_items, -> { where(name: 'relevant') }, class_name: 'LineItem'
 end
 
 class LineItem < ActiveRecord::Base
@@ -94,12 +132,16 @@ class HasManyThroughTest < Minitest::Test
     invoice = Invoice.create!(name: 'relevant')
     irrelevant_invoice = Invoice.create!(name: 'irrelevant')
 
-    line_item = LineItem.create!(task: task, invoice: invoice)
-    irrelevant_line_item = LineItem.create!(task: irrelevant_task, invoice: irrelevant_invoice)
+    line_item = LineItem.create!(name: 'relevant', task: task, invoice: invoice)
+    irrelevant_line_item = LineItem.create!(name: 'relevant', task: irrelevant_task, invoice: irrelevant_invoice)
 
     _work_detail = WorkDetail.create!(line_item: line_item, name: 'relevant')
     _irrelevant_work_detail = WorkDetail.create!(line_item: irrelevant_line_item, name: 'irrelevant')
 
+    blob = Blob.create!()
+    _relevant_attachment = Attachment.create!(name: 'relevant', blob: blob, record: project)
+    _irrelevant_attachment = Attachment.create!(name: 'irrelevant', blob: blob, record: irrelevant_project)
+
     result = Project.where_exists(:invoices, name: 'relevant')
 
     assert_equal 1, result.length
@@ -124,5 +166,28 @@ class HasManyThroughTest < Minitest::Test
 
     assert_equal 1, result.length
     assert_equal irrelevant_project.id, result.first.id
+
+    result = Task.where_exists(:scoped_line_items)
+
+    assert_equal 2, result.length
+
+    result = Project.where_exists(:relevant_blobs)
+
+    assert_equal 1, result.length
+    assert_equal project.id, result.first.id
+
+    result = Project.where_not_exists(:relevant_blobs)
+
+    assert_equal 1, result.length
+    assert_equal irrelevant_project.id, result.first.id
+
+    result = Project.where_exists(:blobs)
+
+    assert_equal 2, result.length
+
+    result = Project.where_not_exists(:blobs)
+
+    assert_equal 0, result.length
+
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: where_exists
 version: !ruby/object:Gem::Version
-  version: 1.1.3
+  version: 1.2.2
 platform: ruby
 authors:
 - Eugene Zolotarev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-21 00:00:00.000000000 Z
+date: 2020-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -19,7 +19,7 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '6.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +29,21 @@ dependencies:
         version: '4.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '6'
+        version: '6.2'
 - !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
@@ -94,11 +94,13 @@ 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
@@ -124,17 +126,17 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: "#where_exists extension of ActiveRecord"
 test_files:
-- test/belongs_to_polymorphic_test.rb
-- test/belongs_to_test.rb
-- test/documentation_test.rb
 - test/has_and_belongs_to_many.rb
-- test/has_many_polymorphic_test.rb
-- test/has_many_test.rb
+- test/belongs_to_polymorphic_test.rb
 - test/has_many_through_test.rb
+- test/db/test.db
 - test/test_helper.rb
+- test/has_many_polymorphic_test.rb
+- test/has_many_test.rb
+- test/documentation_test.rb
+- test/belongs_to_test.rb