where_exists 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3183fa7ecdfc73c32ee05f640fcd732b86a6b2a4
+  data.tar.gz: c6a3fec1c884fa8a817d0cf89827644accc03e03
+SHA512:
+  metadata.gz: 6270202fd65580dff8c02681a877f79a5627e8c5e5477fa90e69ec2572ac8d90bc9941f2ff8bfb0bb219168dd3fb707c6990e49cdc1fbea845bc3d5611ed1f78
+  data.tar.gz: 9a1aeac1ec732eee43e42760ba2013351960b86a87ee5282a1658f10a84ea21782b2822094c422644ff399dc59cd4e13d649e5f357f47228f36e169762225b29

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Eugene Zolotarev
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'WhereExists'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/where_exists.rb

@@ -0,0 +1,110 @@
+require 'active_record'
+
+module WhereExists
+  def where_exists(association_name, where_parameters = {})
+    where_exists_or_not_exists(true, association_name, where_parameters)
+  end
+
+  def where_not_exists(association_name, where_parameters = {})
+    where_exists_or_not_exists(false, association_name, where_parameters)
+  end
+
+  protected
+
+  def where_exists_or_not_exists(does_exist, association_name, where_parameters)
+    association = self.reflect_on_association(association_name)
+
+    unless association
+      raise ArgumentError.new("where_exists: association #{association_name.inspect} not found on #{self.name}")
+    end
+
+    case association.macro
+    when :belongs_to
+      queries = where_exists_for_belongs_to_query(association, where_parameters)
+    when :has_many, :has_one
+      queries = where_exists_for_has_many_query(association, where_parameters)
+    else
+      raise ArgumentError.new("where_exists: not supported association – #{association.macros.inspect}")
+    end
+
+    if does_exist
+      not_string = ""
+    else
+      not_string = "NOT "
+    end
+
+    #queries.map!{|query| query.select(ActiveRecord::FinderMethods::ONE_AS_ONE).where(where_parameters)}
+
+    queries_sql = queries.map{|query| "EXISTS (" + query.to_sql + ")"}.join(" OR ")
+
+    self.where("#{not_string}(#{queries_sql})")
+  end
+
+  def where_exists_for_belongs_to_query(association, where_parameters)
+    polymorphic = association.options[:polymorphic].present?
+
+    if polymorphic
+      associated_models = self.select("DISTINCT #{connection.quote_column_name(association.foreign_type)}").pluck(association.foreign_type).map(&:constantize)
+    else
+      associated_models = [association.klass]
+    end
+
+    queries = []
+
+    self_ids = quote_table_and_column_name(self.table_name, association.foreign_key)
+    self_type = quote_table_and_column_name(self.table_name, association.foreign_type)
+
+    associated_models.each do |associated_model|
+      other_ids = quote_table_and_column_name(associated_model.table_name, associated_model.primary_key)
+      query = associated_model.select("1").where("#{self_ids} = #{other_ids}").where(where_parameters)
+      if polymorphic
+        other_type = connection.quote(associated_model.name)
+        query = query.where("#{self_type} = #{other_type}")
+      end
+      queries.push query
+    end
+
+    queries
+  end
+
+  def where_exists_for_has_many_query(association, where_parameters)
+    through = association.options[:through].present?
+
+    if through
+      original_association_name = association.name
+      association = association.through_reflection
+    end
+
+    associated_model = association.klass
+
+    self_ids = quote_table_and_column_name(self.table_name, self.primary_key)
+    associated_ids = quote_table_and_column_name(associated_model.table_name, association.foreign_key)
+
+    result = associated_model.select("1").where("#{associated_ids} = #{self_ids}")
+
+    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}")
+    end
+
+    if through
+      unless associated_model.reflect_on_association(original_association_name)
+        original_association_name = original_association_name.to_s.singularize.to_sym
+      end
+      result = result.where_exists(original_association_name, where_parameters)
+    else
+      result = result.where(where_parameters)
+    end
+
+    [result]
+  end
+
+  def quote_table_and_column_name(table_name, column_name)
+    connection.quote_table_name(table_name) + '.' + connection.quote_column_name(column_name)
+  end
+end
+
+class ActiveRecord::Base
+  extend WhereExists
+end

data/lib/where_exists/version.rb

@@ -0,0 +1,3 @@
+module WhereExists
+  VERSION = "0.1"
+end

data/test/belongs_to_polymorphic_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+ActiveRecord::Migration.create_table :first_polymorphic_entities, :force => true do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :second_polymorphic_entities, :force => true do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :polymorphic_children, :force => true do |t|
+  t.integer :polymorphic_entity_id
+  t.string :polymorphic_entity_type
+  t.string :name
+end
+
+class PolymorphicChild < ActiveRecord::Base
+  belongs_to :polymorphic_entity, polymorphic: true
+end
+
+class FirstPolymorphicEntity < ActiveRecord::Base
+  has_many :children, as: :polymorphic_entity, class_name: PolymorphicChild
+end
+
+class SecondPolymorphicEntity < ActiveRecord::Base
+  has_many :children, as: :polymorphic_entity, class_name: PolymorphicChild
+end
+
+class BelongsToPolymorphicTest < Minitest::Unit::TestCase
+  def setup
+    ActiveRecord::Base.descendants.each(&:delete_all)
+  end
+
+  def test_exists_only_one_kind
+    first_entity = FirstPolymorphicEntity.create!
+    second_entity = SecondPolymorphicEntity.create!
+    second_entity.update_column(:id, first_entity.id + 1)
+
+    first_child = PolymorphicChild.create!(polymorphic_entity: first_entity)
+    second_child = PolymorphicChild.create!(polymorphic_entity: second_entity)
+    really_orphaned_child = PolymorphicChild.create!(polymorphic_entity_type: 'FirstPolymorphicEntity', polymorphic_entity_id: second_entity.id)
+    another_really_orphaned_child = PolymorphicChild.create!(polymorphic_entity_type: 'SecondPolymorphicEntity', polymorphic_entity_id: first_entity.id)
+
+    result = PolymorphicChild.where_exists(:polymorphic_entity)
+
+    assert_equal 2, result.length
+    assert_equal [first_child, second_child].map(&:id).sort, result.map(&:id).sort
+  end
+
+  def test_neither_exists
+    first_entity = FirstPolymorphicEntity.create!
+    second_entity = SecondPolymorphicEntity.create!
+    second_entity.update_column(:id, first_entity.id + 1)
+
+    first_child = PolymorphicChild.create!(polymorphic_entity: first_entity)
+    orphaned_child = PolymorphicChild.create!(polymorphic_entity_id: second_entity.id, polymorphic_entity_type: 'FirstPolymorphicEntity')
+
+    result = PolymorphicChild.where_not_exists(:polymorphic_entity)
+
+    assert_equal 1, result.length
+    assert_equal orphaned_child.id, result.first.id
+  end
+end

data/test/belongs_to_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+ActiveRecord::Migration.create_table :simple_entities, :force => true do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :simple_entity_children, :force => true do |t|
+  t.integer :simple_entity_id
+  t.string :name
+end
+
+class SimpleEntity < ActiveRecord::Base
+  has_many :simple_entity_children
+end
+
+class SimpleEntityChild < ActiveRecord::Base
+  belongs_to :simple_entity
+end
+
+class BelongsToTest < Minitest::Unit::TestCase
+  def setup
+    ActiveRecord::Base.descendants.each(&:delete_all)
+  end
+
+  def test_nil_foreign_key
+    entity = SimpleEntity.create!
+
+    child = SimpleEntityChild.create!(simple_entity_id: entity.id)
+    orphaned_child = SimpleEntityChild.create!(simple_entity_id: nil)
+
+    result = SimpleEntityChild.where_exists(:simple_entity)
+
+    assert_equal 1, result.length
+    assert_equal result.first.id, child.id
+  end
+
+  def test_not_existing_foreign_object
+    entity = SimpleEntity.create!
+
+    child = SimpleEntityChild.create!(simple_entity_id: entity.id)
+    orphaned_child = SimpleEntityChild.create!(simple_entity_id: entity.id + 1)
+
+    result = SimpleEntityChild.where_exists(:simple_entity)
+
+    assert_equal 1, result.length
+    assert_equal result.first.id, child.id
+  end
+end

data/test/has_many_polymorphic_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+ActiveRecord::Migration.create_table :relevant_polymorphic_entities, :force => true do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :irrelevant_polymorphic_entities, :force => true do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :polymorphic_children, :force => true do |t|
+  t.integer :polymorphic_entity_id
+  t.string :polymorphic_entity_type
+  t.string :name
+end
+
+class PolymorphicChild < ActiveRecord::Base
+  belongs_to :polymorphic_entity, polymorphic: true
+end
+
+class RelevantPolymorphicEntity < ActiveRecord::Base
+  has_many :children, as: :polymorphic_entity, class_name: PolymorphicChild
+end
+
+class IrrelevantPolymorphicEntity < ActiveRecord::Base
+  has_many :children, as: :polymorphic_entity, class_name: PolymorphicChild
+end
+
+class HasManyPolymorphicTest < Minitest::Unit::TestCase
+  def setup
+    ActiveRecord::Base.descendants.each(&:delete_all)
+  end
+
+  def test_polymorphic
+    child = PolymorphicChild.create!
+
+    irrelevant_entity = IrrelevantPolymorphicEntity.create!(children: [child])
+    relevant_entity = RelevantPolymorphicEntity.create!(id: irrelevant_entity.id)
+
+    result = RelevantPolymorphicEntity.where_exists(:children)
+
+    assert_equal 0, result.length
+  end
+end

data/test/has_many_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+ActiveRecord::Migration.create_table :simple_entities, :force => true do |t|
+  t.string :name
+end
+
+ActiveRecord::Migration.create_table :simple_entity_children, :force => true do |t|
+  t.integer :simple_entity_id
+  t.string :name
+end
+
+class SimpleEntity < ActiveRecord::Base
+  has_many :simple_entity_children
+end
+
+class SimpleEntityChild < ActiveRecord::Base
+  belongs_to :simple_entity
+end
+
+class HasManyTest < Minitest::Unit::TestCase
+  def setup
+    ActiveRecord::Base.descendants.each(&:delete_all)
+  end
+
+  def test_without_parameters
+    child = SimpleEntityChild.create!
+
+    blank_entity = SimpleEntity.create!
+    filled_entity = SimpleEntity.create!(simple_entity_children: [child])
+
+    result = SimpleEntity.where_exists(:simple_entity_children)
+
+    assert_equal 1, result.length
+    assert_equal result.first.id, filled_entity.id
+  end
+
+  def test_with_parameters
+    wrong_child = SimpleEntityChild.create!(name: 'wrong')
+    child = SimpleEntityChild.create!(name: 'right')
+
+    blank_entity = SimpleEntity.create!
+    wrong_entity = SimpleEntity.create!(simple_entity_children: [wrong_child])
+    entity = SimpleEntity.create!(name: 'this field is irrelevant', simple_entity_children: [child])
+
+    result = SimpleEntity.where_exists(:simple_entity_children, name: 'right')
+
+    assert_equal 1, result.length
+    assert_equal result.first.id, entity.id
+  end
+
+  def test_with_scope
+    child = SimpleEntityChild.create!
+    entity = SimpleEntity.create!(simple_entity_children: [child])
+
+    result = SimpleEntity.unscoped.where_exists(:simple_entity_children)
+
+    assert_equal 1, result.length
+    assert_equal result.first.id, entity.id
+  end
+
+  def test_not_exists
+    child = SimpleEntityChild.create!
+
+    blank_entity = SimpleEntity.create!
+    filled_entity = SimpleEntity.create!(simple_entity_children: [child])
+
+    result = SimpleEntity.where_not_exists(:simple_entity_children)
+
+    assert_equal 1, result.length
+    assert_equal result.first.id, blank_entity.id
+  end
+end

data/test/has_many_through_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+ActiveRecord::Migration.create_table :projects, :force => true do |t|
+  t.string :name
+end
+
+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|
+  t.string :name
+  t.integer :invoice_id
+  t.integer :task_id
+end
+
+ActiveRecord::Migration.create_table :invoices, :force => true do |t|
+  t.string :name
+end
+
+class Project < ActiveRecord::Base
+  has_many :tasks
+  has_many :invoices, :through => :tasks
+  has_many :line_items, :through => :tasks
+end
+
+class Task < ActiveRecord::Base
+  belongs_to :project
+
+  has_many :invoices, :through => :line_items
+  has_many :line_items
+end
+
+class LineItem < ActiveRecord::Base
+  belongs_to :invoice
+  belongs_to :task
+end
+
+class Invoice < ActiveRecord::Base
+  has_many :tasks, :through => :line_item
+  has_many :line_items
+end
+
+# Invoices ->  LineItems <- Tasks <- Project
+
+class HasManyThroughTest < Minitest::Unit::TestCase
+  def setup
+    ActiveRecord::Base.descendants.each(&:delete_all)
+  end
+
+  def test_one_level_through
+    project = Project.create!
+    irrelevant_project = Project.create!
+
+    task = Task.create!(project: project)
+    irrelevant_task = Task.create!(project: irrelevant_project)
+
+    line_item = LineItem.create!(name: 'relevant', task: task)
+    irrelevant_line_item = LineItem.create!(name: 'irrelevant', task: irrelevant_task)
+
+    result = Project.where_exists(:line_items, name: 'relevant')
+
+    assert_equal 1, result.length
+    assert_equal project.id, result.first.id
+
+    result = Project.where_not_exists(:line_items, name: 'relevant')
+    assert_equal 1, result.length
+    assert_equal irrelevant_project.id, result.first.id
+  end
+
+  def test_deep_through
+    project = Project.create!
+    irrelevant_project = Project.create!
+
+    task = Task.create!(project: project)
+    irrelevant_task = Task.create!(project: irrelevant_project)
+
+    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)
+
+    result = Project.where_exists(:invoices, name: 'relevant')
+
+    assert_equal 1, result.length
+    assert_equal project.id, result.first.id
+
+    result = Project.where_not_exists(:invoices, name: 'relevant')
+
+    assert_equal 1, result.length
+    assert_equal irrelevant_project.id, result.first.id
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'bundler/setup'
+Bundler.require(:default)
+require 'active_record'
+require File.dirname(__FILE__) + '/../lib/where_exists'
+
+ActiveRecord::Base.default_timezone = :utc
+ActiveRecord::Base.time_zone_aware_attributes = true
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'sqlite3',
+  :database => File.dirname(__FILE__) + "/db/test.db"
+)

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: where_exists
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Eugene Zolotarev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.22
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.22
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Rails way to harness the power of SQL "EXISTS" statement
+email:
+- eugzol@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- 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/has_many_polymorphic_test.rb
+- test/has_many_test.rb
+- test/has_many_through_test.rb
+- test/test_helper.rb
+homepage: http://github.com/eugzol/where_exists
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.4
+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/db/test.db
+- test/has_many_polymorphic_test.rb
+- test/has_many_test.rb
+- test/has_many_through_test.rb
+- test/test_helper.rb