c80_active_record_union 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd19d96b28ba3d5890207d1e3111a60c75697a45
+  data.tar.gz: 73b46e8ed3b35ff0db3887bba2b4bdba39f74182
+SHA512:
+  metadata.gz: 07c4b25ed7676c9fb4c8ee2091c5fb07e64f72c75e74e952302b0fdbcc08f4725886a19a2608bd34d64150de22b1fbce132fa26bedec376745dfabd680f96c09
+  data.tar.gz: 26b9395b0434eba2098a433dc1f7f6654135e3b97ea5b01cde302592753c5fb8f539dfc2cbe7e6128839b2b94f334ec9893e7d53b57a15353bffe633b7258a6f

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+*.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
+.idea/

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+addons:
+  postgresql: "9.4"
+rvm:
+  - 2.3.1
+  - 2.2.5
+  - 2.1.8
+  - 2.0.0
+gemfile:
+  - rails_4_2.gemfile
+  - rails_5_0.gemfile
+matrix:
+  exclude:
+  # Rails 5 requires Ruby 2.2+:
+  - rvm: 2.1.8
+    gemfile: rails_5_0.gemfile
+  - rvm: 2.0.0
+    gemfile: rails_5_0.gemfile
+script: bundle exec rspec

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.
+
+This public domain dedication follows the the CC0 1.0 at https://creativecommons.org/publicdomain/zero/1.0/

data/README.md

@@ -0,0 +1,220 @@
+# 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.
+
+Quick usage examples:
+
+```ruby
+current_user.posts.union(Post.published)
+current_user.posts.union(Post.published).where(id: [6, 7])
+current_user.posts.union("published_at < ?", Time.now)
+user_1.posts.union(user_2.posts).union(Post.published)
+user_1.posts.union_all(user_2.posts)
+```
+
+ActiveRecordUnion is tested against Rails 4.2 and Rails 5.0. It may or may not work on Rails 4.0/4.1.
+
+## 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 `union` and `union_all` methods 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:
+
+```sql
+SELECT "posts".* FROM (
+  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 1
+  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" = 1
+  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 accept 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" = 1
+    UNION
+    SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 2
+  ) "posts"
+  UNION
+  SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:12:45.882648')
+) "posts"
+```
+
+### UNION ALL
+
+By default, UNION will remove any duplicates from the result set. If you don't care about duplicates or you know that the two queries you are combining will not have duplicates, you call use UNION ALL to tell the database to skip its deduplication step. In some cases this can give significant performance improvements.
+
+```ruby
+user_1.posts.union_all(user_2.posts)
+```
+```sql
+SELECT "posts".* FROM (
+  SELECT "posts".* FROM "posts" WHERE "posts"."user_id" = 1
+  UNION ALL
+  SELECT "posts".* FROM "posts" WHERE "posts"."user_id" = 2
+) "posts"
+```
+
+## Caveats
+
+There's a couple things to be aware of when using ActiveRecordUnion:
+
+1. ActiveRecordUnion with raise an error if you try to UNION any relations that do any preloading/eager-loading. There's no sensible way to do the preloading in the subselects. If enough people complain maybe we can change ActiveRecordUnion to let the queries run anyway but without preloading any records.
+2. There's no easy way to get SQLite to allow ORDER BY in the UNION subselects. If you get a syntax error, you can either write `my_relation.reorder(nil).union(other.reorder(nil))` or switch to Postgres.
+
+## 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" = 1
+  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" = 2
+  )
+```
+
+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" = 1
+  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. Also, on Rails 4.0 and 4.1 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" = ?`.) Rails 4.2's `to_sql` replaces the bind values before showing the SQL string and thus can more readily be used with `find_by_sql`. (E.g. Rails 4.2 `to_sql` would say `WHERE "posts"."user_id" = 1` instead of `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.
+
+## Changelog
+
+**1.2.0** - June 26, 2016
+  - Ready for Rails 5.0! Updates provided by [@glebm](https://github.com/glebm).
+
+**1.1.1** - Mar 19, 2016
+  - Fix broken polymorphic associations and joins due to improper handling of bind values. Fix by [@efradelos](https://github.com/efradelos), reported by [@Machiaweliczny](https://github.com/Machiaweliczny) and [@seandougall](https://github.com/seandougall).
+  - Quote table name aliases properly. Reported by [@odedniv](https://github.com/odedniv).
+
+**1.1.0** - Mar 29, 2015 - Add UNION ALL support, courtesy of [@pic](https://github.com/pic).
+
+**1.0.1** - Sept 2, 2014 - Allow ORDER BY in UNION subselects for databases that support it (not SQLite).
+
+**1.0.0** - July 24, 2014 - Initial release.
+
+## 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.
+
+This public domain dedication follows the the CC0 1.0 at https://creativecommons.org/publicdomain/zero/1.0/
+
+## Contributing
+
+1. Fork it ( https://github.com/brianhempel/active_record_union/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Run the tests:
+  1. Install MySQL and PostgreSQL.
+  2. You may need to create a `test_active_record_union` database on each under the default user.
+  3. Run `rake` to test with all supported Rails versions.
+  4. Run `rake test_rails_4_2` or `rake test_rails_5_0` to test a specific Rails version.
+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,61 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :test_all_gemfiles
+
+module TestTasks
+  module_function
+
+  TEST_CMD = 'bundle exec rspec'
+
+  def run_all(envs, cmd = "bundle install && #{TEST_CMD}", success_message)
+    statuses = envs.map { |env| run(env, cmd) }
+    failed   = statuses.reject(&:first).map(&:last)
+    if failed.empty?
+      $stderr.puts success_message
+    else
+      $stderr.puts "❌  FAILING (#{failed.size}):\n#{failed.map { |env| to_bash_cmd_with_env(cmd, env) } * "\n"}"
+      exit 1
+    end
+  end
+
+  def run_one(env, cmd = "bundle install && #{TEST_CMD}")
+    full_cmd = to_bash_cmd_with_env(cmd, env)
+    exec(full_cmd)
+  end
+
+  def run(env, cmd)
+    Bundler.with_clean_env do
+      full_cmd = to_bash_cmd_with_env(cmd, env)
+      $stderr.puts full_cmd
+      isSuccess = system(full_cmd)
+      [isSuccess, env]
+    end
+  end
+
+  def gemfiles
+    Dir.glob('*.gemfile').sort
+  end
+
+  def to_bash_cmd_with_env(cmd, env)
+    "(export #{env.map { |k, v| "#{k}=#{v}" }.join(' ')}; #{cmd})"
+  end
+end
+
+desc 'Test all Gemfiles'
+task :test_all_gemfiles do
+  envs = TestTasks.gemfiles.map { |gemfile| { 'BUNDLE_GEMFILE' => gemfile } }
+  TestTasks.run_all envs, "✓ Tests pass with all #{envs.size} gemfiles"
+end
+
+
+TestTasks.gemfiles.each do |gemfile|
+  rails_version_underscored = gemfile[/rails_(.+)\.gemfile/, 1]
+
+  desc "Test Rails #{rails_version_underscored.gsub("_", ".")}"
+  task :"test_rails_#{rails_version_underscored}" do
+    env = { 'BUNDLE_GEMFILE' => gemfile }
+    TestTasks.run_one(env)
+  end
+end

data/bin/console

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+# This is for development only.
+
+require "bundler/setup"
+
+Bundler.require(:development)
+require "c80_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/c80_active_record_union.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'c80_active_record_union/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "c80_active_record_union"
+  spec.version       = C80ActiveRecordUnion::VERSION
+  spec.authors       = ["Brian Hempel"]
+  spec.email         = ["plasticchicken@gmail.com"]
+  spec.summary       = %q{UNIONs in ActiveRecord! Adds proper union and union_all methods 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"
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "mysql2"
+end

data/lib/c80_active_record_union.rb

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

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

@@ -0,0 +1,82 @@
+module ActiveRecord
+  class Relation
+    module Union
+
+      SET_OPERATION_TO_AREL_CLASS = {
+        union:     Arel::Nodes::Union,
+        union_all: Arel::Nodes::UnionAll
+      }
+
+      def union(relation_or_where_arg, *args)
+        set_operation(:union, relation_or_where_arg, *args)
+      end
+
+      def union_all(relation_or_where_arg, *args)
+        set_operation(:union_all, relation_or_where_arg, *args)
+      end
+
+      private
+
+      def set_operation(operation, relation_or_where_arg, *args)
+        other = if args.size == 0 && Relation === relation_or_where_arg
+                  relation_or_where_arg
+                else
+                  @klass.where(relation_or_where_arg, *args)
+                end
+
+        # NB::2016-08-10
+        # verify_relations_for_set_operation!(operation, self, other)
+
+        # Postgres allows ORDER BY in the UNION subqueries if each subquery is surrounded by parenthesis
+        # but SQLite does not allow parens around the subqueries; you will have to explicitly do `relation.reorder(nil)` in SQLite
+        if Arel::Visitors::SQLite === self.connection.visitor
+          left, right = self.ast, other.ast
+        else
+          left, right = Arel::Nodes::Grouping.new(self.ast), Arel::Nodes::Grouping.new(other.ast)
+        end
+
+        set  = SET_OPERATION_TO_AREL_CLASS[operation].new(left, right)
+        from = Arel::Nodes::TableAlias.new(set, @klass.arel_table.name)
+        if ActiveRecord::VERSION::MAJOR >= 5
+          relation             = @klass.unscoped.spawn
+          relation.from_clause = UnionFromClause.new(from, nil, self.bound_attributes + other.bound_attributes)
+        else
+          relation             = @klass.unscoped.from(from)
+          relation.bind_values = self.arel.bind_values + self.bind_values + other.arel.bind_values + other.bind_values
+        end
+        relation
+      end
+
+      def verify_relations_for_set_operation!(operation, *relations)
+        includes_relations = relations.select { |r| r.includes_values.any? }
+
+        if includes_relations.any?
+          raise ArgumentError.new("Cannot #{operation} relation with includes.")
+        end
+
+        preload_relations = relations.select { |r| r.preload_values.any? }
+        if preload_relations.any?
+          raise ArgumentError.new("Cannot #{operation} relation with preload.")
+        end
+
+        eager_load_relations = relations.select { |r| r.eager_load_values.any? }
+        if eager_load_relations.any?
+          raise ArgumentError.new("Cannot #{operation} relation with eager load.")
+        end
+      end
+
+      if ActiveRecord::VERSION::MAJOR >= 5
+        class UnionFromClause < ActiveRecord::Relation::FromClause
+          def initialize(value, name, bound_attributes)
+            super(value, name)
+            @bound_attributes = bound_attributes
+          end
+
+          def binds
+            @bound_attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/c80_active_record_union/version.rb

@@ -0,0 +1,3 @@
+module C80ActiveRecordUnion
+  VERSION = "0.1.0"
+end

data/rails_4_2.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec
+
+gem 'rails', '~> 4.2.6'

data/rails_5_0.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec
+
+gem 'rails', ['>= 5.0.0.rc2', '< 5.1']

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+require "bundler/setup"
+
+Bundler.require(:development)
+require "c80_active_record_union"
+
+require "support/databases"
+
+Databases.connect_to_sqlite
+
+# 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/databases.rb

@@ -0,0 +1,49 @@
+module Databases
+  extend self
+
+  def connect_to_sqlite
+    ActiveRecord::Base.establish_connection(
+      adapter:  "sqlite3",
+      database: ":memory:"
+    )
+    load("support/models.rb")
+  end
+
+  def connect_to_postgres
+    ActiveRecord::Base.establish_connection(
+      adapter:  "postgresql"
+    )
+    ActiveRecord::Base.connection.recreate_database("test_active_record_union")
+    ActiveRecord::Base.establish_connection(
+      adapter:  "postgresql",
+      database: "test_active_record_union"
+    )
+    load("support/models.rb")
+  end
+
+  def connect_to_mysql
+    ActiveRecord::Base.establish_connection(
+      adapter:  "mysql2"
+    )
+    ActiveRecord::Base.connection.recreate_database("test_active_record_union")
+    ActiveRecord::Base.establish_connection(
+      adapter:  "mysql2",
+      database: "test_active_record_union"
+    )
+    load("support/models.rb")
+  end
+
+  def with_postgres(&block)
+    connect_to_postgres
+    yield
+  ensure
+    connect_to_sqlite
+  end
+
+  def with_mysql(&block)
+    connect_to_mysql
+    yield
+  ensure
+    connect_to_sqlite
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,18 @@
+ActiveRecord::Base.connection.create_table :users, force: true do |t|
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+  has_many :drafts, -> { where draft: true  }, class_name: "Post"
+end unless defined?(User)
+
+ActiveRecord::Base.connection.create_table :posts, force: true do |t|
+  t.integer   :user_id
+  t.boolean   :draft
+  t.timestamp :published_at
+  t.timestamps null: false
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end unless defined?(Post)

data/spec/union_spec.rb

@@ -0,0 +1,174 @@
+require "spec_helper"
+
+describe ActiveRecord::Relation do
+  TIME     = Time.utc(2014, 7, 19, 0, 0, 0)
+  SQL_TIME = ActiveRecord::VERSION::MAJOR >= 5 ? "2014-07-19 00:00:00" : "2014-07-19 00:00:00.000000"
+
+  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(id: 1).posts.union(Post.where("created_at > ?", TIME))
+
+      expect(union.to_sql.squish).to eq(
+        "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 UNION SELECT \"posts\".* FROM \"posts\" WHERE (created_at > '#{SQL_TIME}') ) \"posts\""
+      )
+      expect(union.arel.to_sql.squish).to eq(
+        "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = ? UNION SELECT \"posts\".* FROM \"posts\" WHERE (created_at > '#{SQL_TIME}') ) \"posts\""
+      )
+      expect{union.to_a}.to_not raise_error
+    end
+
+    def bind_values_from_relation(relation)
+      if ActiveRecord::VERSION::MAJOR >= 5
+        relation.bound_attributes.map { |a| a.value_for_database }
+      else
+        (relation.arel.bind_values + relation.bind_values).map { |_column, value| value }
+      end
+    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)
+
+      # Inside ActiveRecord the bind value list is
+      # (union.arel.bind_values + union.bind_values)
+      bind_values = bind_values_from_relation union
+
+      expect(bind_values).to eq([1, 2, 3])
+    end
+
+    it "binds values properly on joins" do
+      union = User.joins(:drafts).union(User.where(id: 11))
+
+      bind_values = bind_values_from_relation union
+      expect(bind_values).to eq([true, 11])
+
+
+      expect(union.to_sql.squish).to eq(
+        "SELECT \"users\".* FROM ( SELECT \"users\".* FROM \"users\" INNER JOIN \"posts\" ON \"posts\".\"user_id\" = \"users\".\"id\" AND \"posts\".\"draft\" = 't' UNION SELECT \"users\".* FROM \"users\" WHERE \"users\".\"id\" = 11 ) \"users\""
+      )
+      expect{union.to_a}.to_not raise_error
+    end
+
+    it "doesn't repeat default scopes" do
+      expect(Time).to receive(:now) { Time.utc(2014, 7, 24, 0, 0, 0) }
+      sql_now = "2014-07-24 00:00:00#{".000000" if ActiveRecord::VERSION::MAJOR < 5}"
+
+      class PublishedPost < ActiveRecord::Base
+        self.table_name = "posts"
+        default_scope { where("published_at < ?", Time.now) }
+      end
+
+      union = PublishedPost.where("created_at > ?", TIME).union(User.new(id: 1).posts)
+
+      expect(union.to_sql.squish).to eq(
+        "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE (published_at < '#{sql_now}') AND (created_at > '#{SQL_TIME}') UNION SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 ) \"posts\""
+      )
+      expect{union.to_a}.to_not raise_error
+    end
+
+    context "with ORDER BY in subselects" do
+      let :union do
+        User.new(id: 1).posts.order(:created_at).union(
+          Post.where("created_at > ?", TIME).order(:created_at)
+        ).order(:created_at)
+      end
+
+      context "in SQLite" do
+        it "lets ORDER BY in query subselects throw a syntax error" do
+          expect(union.to_sql.squish).to eq(
+            "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 ORDER BY \"posts\".\"created_at\" ASC UNION SELECT \"posts\".* FROM \"posts\" WHERE (created_at > '#{SQL_TIME}') ORDER BY \"posts\".\"created_at\" ASC ) \"posts\" ORDER BY \"posts\".\"created_at\" ASC"
+          )
+          expect{union.to_a}.to raise_error(ActiveRecord::StatementInvalid)
+        end
+      end
+
+      context "in Postgres" do
+        it "wraps query subselects in parentheses to allow ORDER BY clauses" do
+          Databases.with_postgres do
+            expect(union.to_sql.squish).to eq(
+              "SELECT \"posts\".* FROM ( (SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 ORDER BY \"posts\".\"created_at\" ASC) UNION (SELECT \"posts\".* FROM \"posts\" WHERE (created_at > '#{SQL_TIME}') ORDER BY \"posts\".\"created_at\" ASC) ) \"posts\" ORDER BY \"posts\".\"created_at\" ASC"
+            )
+            expect{union.to_a}.to_not raise_error
+          end
+        end
+      end
+
+      context "in MySQL" do
+        it "wraps query subselects in parentheses to allow ORDER BY clauses" do
+          Databases.with_mysql do
+            expect(union.to_sql.squish).to eq(
+              "SELECT `posts`.* FROM ( (SELECT `posts`.* FROM `posts` WHERE `posts`.`user_id` = 1 ORDER BY `posts`.`created_at` ASC) UNION (SELECT `posts`.* FROM `posts` WHERE (created_at > '#{SQL_TIME}') ORDER BY `posts`.`created_at` ASC) ) `posts` ORDER BY `posts`.`created_at` ASC"
+            )
+            expect{union.to_a}.to_not raise_error
+          end
+        end
+      end
+    end
+
+    context "builds a scope when given" do
+      it "a hash" do
+        union = User.new(id: 1).posts.union(id: 2)
+
+        expect(union.to_sql.squish).to eq(
+          "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 UNION SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"id\" = 2 ) \"posts\""
+        )
+        expect{union.to_a}.to_not raise_error
+      end
+
+      it "multiple arguments" do
+        union = User.new(id: 1).posts.union("created_at > ?", TIME)
+
+        expect(union.to_sql.squish).to eq(
+          "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 UNION SELECT \"posts\".* FROM \"posts\" WHERE (created_at > '#{SQL_TIME}') ) \"posts\""
+        )
+        expect{union.to_a}.to_not raise_error
+      end
+
+      it "arel" do
+        union = User.new(id: 1).posts.union(Post.arel_table[:id].eq(2).or(Post.arel_table[:id].eq(3)))
+
+        expect(union.to_sql.squish).to eq(
+          "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 UNION SELECT \"posts\".* FROM \"posts\" WHERE (\"posts\".\"id\" = 2 OR \"posts\".\"id\" = 3) ) \"posts\""
+        )
+        expect{union.to_a}.to_not raise_error
+      end
+    end
+  end
+
+  describe ".union_all" do
+    it "works" do
+      union = User.new(id: 1).posts.union_all(Post.where("created_at > ?", TIME))
+
+      expect(union.to_sql.squish).to eq(
+        "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\" WHERE \"posts\".\"user_id\" = 1 UNION ALL SELECT \"posts\".* FROM \"posts\" WHERE (created_at > '#{SQL_TIME}') ) \"posts\""
+      )
+      expect{union.to_a}.to_not raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification
+name: c80_active_record_union
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brian Hempel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-10 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'
+- !ruby/object:Gem::Dependency
+  name: pg
+  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: mysql2
+  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 proper union and union_all methods to ActiveRecord::Relation.
+email:
+- plasticchicken@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/.rakeTasks"
+- ".travis.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- c80_active_record_union.gemspec
+- lib/c80_active_record_union.rb
+- lib/c80_active_record_union/active_record/relation/union.rb
+- lib/c80_active_record_union/version.rb
+- rails_4_2.gemfile
+- rails_5_0.gemfile
+- spec/spec_helper.rb
+- spec/support/databases.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.5.1
+signing_key: 
+specification_version: 4
+summary: UNIONs in ActiveRecord! Adds proper union and union_all methods to ActiveRecord::Relation.
+test_files:
+- spec/spec_helper.rb
+- spec/support/databases.rb
+- spec/support/models.rb
+- spec/union_spec.rb
+- bin/console