active_record_union 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3eba1bb2ac0137d8d84b62bb48f45e8c90f78efe
+  data.tar.gz: ef18422b1efeabda133e5e2d86985c918759f1b8
+SHA512:
+  metadata.gz: e318f5d727ea3e1483c67638b824293840ba75f7d0191bf7490d62a32bc17c9dbd8fd7403f652f1fd51294f97b8bd8e33e4445cd83ac36e3956ded6b978efc12
+  data.tar.gz: 961b39db5ef83a66708c6424356189e60837d3eb2068a1c0464da7d7ddc2154cb116bf596f7f73b8b3c46bdffbafafa0774a20c4c0798b5774df71e12b246717

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,3 @@
+ActiveRecordUnion is dedicated to the public domain by its author, Brian Hempel. No rights are reserved. No restrictions are placed on the use of ActiveRecordUnion. That freedom also means, of course, that no warrenty of fitness is claimed; use ActiveRecordUnion at your own risk.
+
+Public domain dedication is explained by the CC0 1.0 summary (and only the summary) at https://creativecommons.org/publicdomain/zero/1.0/

data/README.md

@@ -0,0 +1,169 @@
+# ActiveRecordUnion
+
+[![Gem Version](https://badge.fury.io/rb/active_record_union.svg)](http://badge.fury.io/rb/active_record_union)
+[![Build Status](https://travis-ci.org/brianhempel/active_record_union.svg)](https://travis-ci.org/brianhempel/active_record_union)
+
+Use unions on ActiveRecord scopes without ugliness.
+
+If you find yourself writing `pluck(:id)` and then feeding that into another query, you may be able to reduce the number of database requests by using a nested query or a UNION without writing crazy JOIN statements.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_union'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record_union
+
+## Usage
+
+ActiveRecordUnion adds a `union` method to `ActiveRecord::Relation` so we can easily gather together queries on mutiple scopes.
+
+Consider some users with posts:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+
+  scope :published, -> { where("published_at < ?", Time.now) }
+end
+```
+
+With ActiveRecordUnion, we can do:
+
+```ruby
+# the current user's (draft) posts and all published posts from anyone
+current_user.posts.union(Post.published)
+```
+
+Which is equivalent to the following SQL: [<a href="#footnote-1">1</a>]
+
+```sql
+SELECT "posts".* FROM (
+  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+  UNION
+  SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:04:21.918366')
+) posts
+```
+
+Because the `union` method returns another `ActiveRecord::Relation`, we can run further queries on the union.
+
+```ruby
+current_user.posts.union(Post.published).where(id: [6, 7])
+```
+```sql
+SELECT "posts".* FROM (
+  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+  UNION
+  SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:06:04.460771')
+) posts  WHERE "posts"."id" IN (6, 7)
+```
+
+The `union` method can also accepts anything that `where` does.
+
+```ruby
+current_user.posts.union("published_at < ?", Time.now)
+# equivalent to...
+current_user.posts.union(Post.where("published_at < ?", Time.now))
+```
+
+We can also chain `union` calls to UNION more than two scopes, though the UNIONs will be nested which may not be the prettiest SQL.
+
+```ruby
+user_1.posts.union(user_2.posts).union(Post.published)
+# equivalent to...
+[user_1.posts, user_2.posts, Post.published].inject(:union)
+```
+```sql
+SELECT "posts".* FROM (
+  SELECT "posts".* FROM (
+    SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+    UNION
+    SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+  ) posts
+  UNION
+  SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:12:45.882648')
+) posts
+```
+
+<a name="footnote-1"></a>[1] Note: the `?` in the SQL is bound to the correct value when ActiveRecord executes the query. Also, the SQL examples here were generated for a SQLite database. The syntax generated for other databases may vary slightly.
+
+## Another nifty way to reduce extra queries
+
+ActiveRecord already supports turning scopes into nested queries in WHERE clauses. The nested relation defaults to selecting `id` by default.
+
+For example, if a user `has_and_belongs_to_many :favorited_posts`, we can quickly find which of the current user's posts are liked by a certain other user.
+
+```ruby
+current_user.posts.where(id: other_user.favorited_posts)
+```
+```sql
+SELECT "posts".* FROM "posts"
+  WHERE "posts"."user_id" = ?
+  AND "posts"."id" IN (
+    SELECT "posts"."id"
+      FROM "posts" INNER JOIN "user_favorited_posts" ON "posts"."id" = "user_favorited_posts"."post_id"
+      WHERE "user_favorited_posts"."user_id" = ?
+  )
+```
+
+If we want to select something other than `id`, we use `select` to specify. The following is equivalent to the above, but the query is done against the join table.
+
+```ruby
+current_user.posts.where(id: UserFavoritedPost.where(user_id: other_user.id).select(:post_id))
+```
+```sql
+SELECT "posts".* FROM "posts"
+  WHERE "posts"."user_id" = ?
+  AND "posts"."id" IN (
+    SELECT "user_favorited_posts"."post_id"
+      FROM "user_favorited_posts"
+      WHERE "user_favorited_posts"."user_id" = 2
+  )
+```
+
+(The above example is illustrative only. It might be better with a JOIN.)
+
+## State of the Union in ActiveRecord
+
+Why does this gem exist?
+
+Right now in ActiveRecord, if we call `scope.union` we get an `Arel::Nodes::Union` object instead of an `ActiveRecord::Relation`.
+
+We could call `to_sql` on the Arel object and then use `find_by_sql`, but that's not super clean and if the original scopes included an association, then the `to_sql` may produce a query with values that need to be bound (represented by `?`s in the SQL) and we have to provide those ourselves. (E.g. `user.posts.to_sql` produces `SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?`.)
+
+While ActiveRecord may eventually have the ability to cleanly perform UNIONs, it's currently stalled. If you're interested, the relevant URLs as of July 2014 are:
+
+https://github.com/rails/rails/issues/939 and
+https://github.com/rails/arel/pull/239 and
+https://github.com/yakaz/rails/commit/29b8ebd187e0888d5e71b2e1e4a12334860bc76c
+
+This is a gem not a Rails pull request because the standard of code quality for a PR is a bit higher, and we'd have to wait for the PR to be merged and relased to use UNIONs. That said, the code here is fairly clean and it may end up in a PR sometime.
+
+## License
+
+ActiveRecordUnion is dedicated to the public domain by its author, Brian Hempel. No rights are reserved. No restrictions are placed on the use of ActiveRecordUnion. That freedom also means, of course, that no warrenty of fitness is claimed; use ActiveRecordUnion at your own risk.
+
+Public domain dedication is explained by the CC0 1.0 summary (and only the summary) at https://creativecommons.org/publicdomain/zero/1.0/
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/active_record_union/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run the tests with `rspec`
+4. There is also a `bin/console` command to load up a REPL for playing around
+5. Commit your changes (`git commit -am 'Add some feature'`)
+6. Push to the branch (`git push origin my-new-feature`)
+7. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+task :default => :spec
+
+desc "Run the tests"
+task :spec do
+  exec("bundle exec rspec")
+end

data/active_record_union.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_record_union/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_record_union"
+  spec.version       = ActiveRecordUnion::VERSION
+  spec.authors       = ["Brian Hempel"]
+  spec.email         = ["plasticchicken@gmail.com"]
+  spec.summary       = %q{UNIONs in ActiveRecord! Adds a proper union method to ActiveRecord::Relation.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/brianhempel/active_record_union"
+  spec.license       = "Public Domain"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  # spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/}) + spec.files.grep(%r{^bin/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec",   "~> 3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "sqlite3"
+end

data/bin/console

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+# This is for development only.
+
+require "bundler/setup"
+
+Bundler.require(:development)
+require "active_record_union"
+
+ActiveRecord::Base.establish_connection(
+  adapter:  "sqlite3",
+  database: ":memory:"
+)
+
+require File.expand_path("../../spec/support/models.rb", __FILE__)
+
+# extensions over models.rb to help with making the README
+
+class User
+  has_and_belongs_to_many :favorited_posts,
+    class_name: "Post",
+    join_table: "user_favorited_posts"
+end
+
+class UserFavoritedPost < ActiveRecord::Base
+  connection.create_table :user_favorited_posts, force: true do |t|
+    t.integer :post_id
+    t.integer :user_id
+  end
+end
+
+class Post
+  scope :published, -> { where("published_at < ?", Time.now) }
+end
+
+binding.pry

data/lib/active_record_union.rb

@@ -0,0 +1,9 @@
+require "active_record_union/version"
+require "active_record"
+require "active_record_union/active_record/relation/union"
+
+module ActiveRecord
+  class Relation
+    include Union
+  end
+end

data/lib/active_record_union/active_record/relation/union.rb

@@ -0,0 +1,41 @@
+module ActiveRecord
+  class Relation
+    module Union
+      def union(relation_or_where_arg, *args)
+        other   = relation_or_where_arg if args.size == 0 && Relation === relation_or_where_arg
+        other ||= @klass.where(relation_or_where_arg, *args)
+
+        verify_union_relations!(self, other)
+
+        union = self.arel.union(other)
+        from = Arel::Nodes::TableAlias.new(
+          union,
+          Arel::Nodes::SqlLiteral.new(@klass.arel_table.name)
+        )
+
+        relation = @klass.unscoped.from(from)
+        relation.bind_values = self.bind_values + other.bind_values + relation.bind_values
+        relation
+      end
+
+      private
+      
+      def verify_union_relations!(*args)
+        includes_relations = args.select { |r| r.includes_values.any? }
+        if includes_relations.any?
+          raise ArgumentError.new("Cannot union relation with includes.")
+        end
+
+        preload_relations = args.select { |r| r.preload_values.any? }
+        if preload_relations.any?
+          raise ArgumentError.new("Cannot union relation with preload.")
+        end
+
+        eager_load_relations = args.select { |r| r.eager_load_values.any? }
+        if eager_load_relations.any?
+          raise ArgumentError.new("Cannot union relation with eager load.")
+        end
+      end
+    end
+  end
+end

data/lib/active_record_union/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordUnion
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require "active_record_union"
+
+ActiveRecord::Base.establish_connection(
+  adapter:  "sqlite3",
+  database: ":memory:"
+)
+
+require "support/models"
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,15 @@
+class User < ActiveRecord::Base
+  connection.create_table :users, force: true do |t|
+  end
+
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  connection.create_table :posts, force: true do |t|
+    t.integer :user_id
+    t.timestamps
+  end
+
+  belongs_to :user
+end

data/spec/union_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe ActiveRecord::Relation do
+  describe ".union" do
+    it "returns an ActiveRecord::Relation" do
+      expect(User.all.union(User.all)).to be_kind_of(ActiveRecord::Relation)
+    end
+
+    it "requires an argument" do
+      expect{User.all.union}.to raise_error(ArgumentError)
+    end
+
+    it "explodes if asked to union a relation with includes" do
+      expect{User.all.union(User.includes(:posts))}.to raise_error(ArgumentError)
+      expect{User.includes(:posts).union(User.all)}.to raise_error(ArgumentError)
+    end
+
+    it "explodes if asked to union a relation with preload values" do
+      expect{User.all.union(User.preload(:posts))}.to raise_error(ArgumentError)
+      expect{User.preload(:posts).union(User.all)}.to raise_error(ArgumentError)
+    end
+
+    it "explodes if asked to union a relation with eager loading" do
+      expect{User.all.union(User.eager_load(:posts))}.to raise_error(ArgumentError)
+      expect{User.eager_load(:posts).union(User.all)}.to raise_error(ArgumentError)
+    end
+
+    it "works" do
+      union = User.new.posts.union(Post.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)))
+
+      expect(union.to_sql).to eq(
+        "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"user_id\" = ? UNION SELECT \"posts\".* FROM \"posts\"  WHERE (created_at > '2014-07-19 00:00:00.000000') ) posts"
+      )
+    end
+
+    it "binds values properly" do
+      user1 = User.new(id: 1)
+      user2 = User.new(id: 2)
+      user3 = User.new(id: 3)
+
+      union = user1.posts.union(user2.posts).where.not(id: user3.posts)
+      bind_values = union.bind_values.map { |column, value| value }
+
+      expect(bind_values).to eq([1, 2, 3])
+    end
+
+    it "doesn't repeat default scopes" do
+      expect(Time).to receive(:now) { Time.utc(2014, 7, 24, 0, 0, 0) }
+
+      class PublishedPost < ActiveRecord::Base
+        self.table_name = "posts"
+        default_scope { where("published_at < ?", Time.now) }
+      end
+
+      union = PublishedPost.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)).union(User.new.posts)
+
+      expect(union.to_sql).to eq(
+        "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\"  WHERE (published_at < '2014-07-24 00:00:00.000000') AND (created_at > '2014-07-19 00:00:00.000000') UNION SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"user_id\" = ? ) posts"
+      )
+    end
+
+    context "builds a scope when given" do
+      it "a hash" do
+        union = User.new.posts.union(id: 1)
+
+        expect(union.to_sql).to eq(
+          "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"user_id\" = ? UNION SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"id\" = 1 ) posts"
+        )
+      end
+
+      it "multiple arguments" do
+        union = User.new.posts.union("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0))
+
+        expect(union.to_sql).to eq(
+          "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"user_id\" = ? UNION SELECT \"posts\".* FROM \"posts\"  WHERE (created_at > '2014-07-19 00:00:00.000000') ) posts"
+        )
+      end
+
+      it "arel" do
+        union = User.new.posts.union(Post.arel_table[:id].eq(1).or(Post.arel_table[:id].eq(2)))
+
+        expect(union.to_sql).to eq(
+          "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"user_id\" = ? UNION SELECT \"posts\".* FROM \"posts\"  WHERE ((\"posts\".\"id\" = 1 OR \"posts\".\"id\" = 2)) ) posts"
+        )
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: active_record_union
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brian Hempel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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: UNIONs in ActiveRecord! Adds a proper union method to ActiveRecord::Relation.
+email:
+- plasticchicken@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_record_union.gemspec
+- bin/console
+- lib/active_record_union.rb
+- lib/active_record_union/active_record/relation/union.rb
+- lib/active_record_union/version.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/union_spec.rb
+homepage: https://github.com/brianhempel/active_record_union
+licenses:
+- Public Domain
+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.2.2
+signing_key: 
+specification_version: 4
+summary: UNIONs in ActiveRecord! Adds a proper union method to ActiveRecord::Relation.
+test_files:
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/union_spec.rb
+- bin/console