active_record_union 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: de7279017756c9ab6fa65a13d457b671d4d3fc1f
-  data.tar.gz: a059566a08659d432635c1ad707431a3b8c163a1
+  metadata.gz: 0e5aaf90d66c3e15eb7e2c225283b0c2790b146b
+  data.tar.gz: fb36ac1c86da58e19de86409e9bd3c35897e247f
 SHA512:
-  metadata.gz: bc0aae94fd243b66458b8ad719833bea64c69be694eaa5a73e370c3aea1dd918b74e15463b8c03b7d5c7d808db526bc0de3b06f27e8d27087e1678c0d0441b70
-  data.tar.gz: 0481dcf3092a0e166bcca93da7e9b1634d999cdecfd7ef14d108ab95ab2c291c9d8cf8e77f232b946da5beba0aec78ecb2036abaa5536668656655af6f908a0e
+  metadata.gz: 3b0140dffec59d1214dc18c456dad0ff28c24f1262704ab7628af0f679dc08c5e30d9d8effcbff29fa4f6800894579b82f2663d15a1341b895512546f366c109
+  data.tar.gz: 9683ecd6bd506d3226a04ddb3abcd461a7a3adb0088d0f577069569965bac460480bf35f5dd26fcf966779a24a0f1cb32cf531e5c8600dea86769ec540416c26

data/LICENSE.txt

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

data/README.md

@@ -25,7 +25,7 @@ Or install it yourself as:
 
 ## Usage
 
-ActiveRecordUnion adds a `union` method to `ActiveRecord::Relation` so we can easily gather together queries on mutiple scopes.
+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:
 
@@ -48,11 +48,11 @@ With ActiveRecordUnion, we can do:
 current_user.posts.union(Post.published)
 ```
 
-Which is equivalent to the following SQL: [<a href="#footnote-1">1</a>]
+Which is equivalent to the following SQL:
 
 ```sql
 SELECT "posts".* FROM (
-  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+  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
@@ -65,13 +65,13 @@ current_user.posts.union(Post.published).where(id: [6, 7])
 ```
 ```sql
 SELECT "posts".* FROM (
-  SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+  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 accepts anything that `where` does.
+The `union` method can also accept anything that `where` does.
 
 ```ruby
 current_user.posts.union("published_at < ?", Time.now)
@@ -89,16 +89,29 @@ user_1.posts.union(user_2.posts).union(Post.published)
 ```sql
 SELECT "posts".* FROM (
   SELECT "posts".* FROM (
-    SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+    SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 1
     UNION
-    SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = ?
+    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
 ```
 
-<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.
+### 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
 
@@ -118,11 +131,11 @@ current_user.posts.where(id: other_user.favorited_posts)
 ```
 ```sql
 SELECT "posts".* FROM "posts"
-  WHERE "posts"."user_id" = ?
+  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" = ?
+      WHERE "user_favorited_posts"."user_id" = 2
   )
 ```
 
@@ -133,7 +146,7 @@ current_user.posts.where(id: UserFavoritedPost.where(user_id: other_user.id).sel
 ```
 ```sql
 SELECT "posts".* FROM "posts"
-  WHERE "posts"."user_id" = ?
+  WHERE "posts"."user_id" = 1
   AND "posts"."id" IN (
     SELECT "user_favorited_posts"."post_id"
       FROM "user_favorited_posts"
@@ -149,7 +162,7 @@ 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" = ?`.)
+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:
 
@@ -161,6 +174,8 @@ This is a gem not a Rails pull request because the standard of code quality for
 
 ## Changelog
 
+**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.
@@ -169,11 +184,11 @@ This is a gem not a Rails pull request because the standard of code quality for
 
 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/
+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/[my-github-username]/active_record_union/fork )
+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 with `rspec`
 4. There is also a `bin/console` command to load up a REPL for playing around

data/active_record_union.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
   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.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"

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

@@ -1,11 +1,30 @@
 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)
+      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
+
+        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
@@ -15,9 +34,9 @@ module ActiveRecord
           left, right = Arel::Nodes::Grouping.new(self.ast), Arel::Nodes::Grouping.new(other.ast)
         end
 
-        union = Arel::Nodes::Union.new(left, right)
+        set = SET_OPERATION_TO_AREL_CLASS[operation].new(left, right)
         from = Arel::Nodes::TableAlias.new(
-          union,
+          set,
           Arel::Nodes::SqlLiteral.new(@klass.arel_table.name)
         )
 
@@ -26,22 +45,21 @@ module ActiveRecord
         relation
       end
 
-      private
+      def verify_relations_for_set_operation!(operation, *relations)
+        includes_relations = relations.select { |r| r.includes_values.any? }
 
-      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.")
+          raise ArgumentError.new("Cannot #{operation} relation with includes.")
         end
 
-        preload_relations = args.select { |r| r.preload_values.any? }
+        preload_relations = relations.select { |r| r.preload_values.any? }
         if preload_relations.any?
-          raise ArgumentError.new("Cannot union relation with preload.")
+          raise ArgumentError.new("Cannot #{operation} relation with preload.")
         end
 
-        eager_load_relations = args.select { |r| r.eager_load_values.any? }
+        eager_load_relations = relations.select { |r| r.eager_load_values.any? }
         if eager_load_relations.any?
-          raise ArgumentError.new("Cannot union relation with eager load.")
+          raise ArgumentError.new("Cannot #{operation} relation with eager load.")
         end
       end
     end

data/lib/active_record_union/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordUnion
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/support/models.rb

@@ -8,7 +8,7 @@ end unless defined?(User)
 ActiveRecord::Base.connection.create_table :posts, force: true do |t|
   t.integer   :user_id
   t.timestamp :published_at
-  t.timestamps
+  t.timestamps null: false
 end
 
 class Post < ActiveRecord::Base

data/spec/union_spec.rb

@@ -26,10 +26,13 @@ describe ActiveRecord::Relation do
     end
 
     it "works" do
-      union = User.new.posts.union(Post.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)))
+      union = User.new(id: 1).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"
+      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 > '2014-07-19 00:00:00.000000') ) 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 > '2014-07-19 00:00:00.000000') ) posts"
       )
       expect{union.to_a}.to_not raise_error
     end
@@ -53,25 +56,25 @@ describe ActiveRecord::Relation do
         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)
+      union = PublishedPost.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)).union(User.new(id: 1).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"
+      expect(union.to_sql.squish).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\" = 1 ) posts"
       )
       expect{union.to_a}.to_not raise_error
     end
 
     context "with ORDER BY in subselects" do
       def union
-        User.new.posts.order(:created_at).union(
+        User.new(id: 1).posts.order(:created_at).union(
           Post.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)).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).to eq(
-            "SELECT \"posts\".* FROM ( SELECT \"posts\".* FROM \"posts\"  WHERE \"posts\".\"user_id\" = ?  ORDER BY \"posts\".\"created_at\" ASC UNION SELECT \"posts\".* FROM \"posts\"  WHERE (created_at > '2014-07-19 00:00:00.000000')  ORDER BY \"posts\".\"created_at\" ASC ) posts   ORDER BY \"posts\".\"created_at\" ASC"
+          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 > '2014-07-19 00:00:00.000000') ORDER BY \"posts\".\"created_at\" ASC ) posts ORDER BY \"posts\".\"created_at\" ASC"
           )
           expect{union.to_a}.to raise_error(ActiveRecord::StatementInvalid)
         end
@@ -80,8 +83,8 @@ describe ActiveRecord::Relation do
       context "in Postgres" do
         it "wraps query subselects in parentheses to allow ORDER BY clauses" do
           Databases.with_postgres do
-            expect(union.to_sql).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 > '2014-07-19 00:00:00.000000')  ORDER BY \"posts\".\"created_at\" ASC) ) posts   ORDER BY \"posts\".\"created_at\" ASC"
+            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 > '2014-07-19 00:00:00.000000') ORDER BY \"posts\".\"created_at\" ASC) ) posts ORDER BY \"posts\".\"created_at\" ASC"
             )
             expect{union.to_a}.to_not raise_error
           end
@@ -91,7 +94,7 @@ describe ActiveRecord::Relation do
       context "in MySQL" do
         it "wraps query subselects in parentheses to allow ORDER BY clauses" do
           Databases.with_mysql do
-            expect(union.to_sql).to eq(
+            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 > '2014-07-19 00:00:00.000000')  ORDER BY \"posts\".\"created_at\" ASC) ) posts   ORDER BY \"posts\".\"created_at\" ASC"
             )
             expect{union.to_a}.to_not raise_error
@@ -102,28 +105,39 @@ describe ActiveRecord::Relation do
 
     context "builds a scope when given" do
       it "a hash" do
-        union = User.new.posts.union(id: 1)
+        union = User.new(id: 1).posts.union(id: 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 ) posts"
+        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"
         )
       end
 
       it "multiple arguments" do
-        union = User.new.posts.union("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0))
+        union = User.new(id: 1).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"
+        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 > '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)))
+        union = User.new(id: 1).posts.union(Post.arel_table[:id].eq(2).or(Post.arel_table[:id].eq(3)))
 
-        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"
+        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"
         )
       end
     end
   end
+
+  describe ".union_all" do
+    it "works" do
+      union = User.new(id: 1).posts.union_all(Post.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)))
+
+      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 > '2014-07-19 00:00:00.000000') ) posts"
+      )
+      expect{union.to_a}.to_not raise_error
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_union
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Brian Hempel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-02 00:00:00.000000000 Z
+date: 2015-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -122,7 +122,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: UNIONs in ActiveRecord! Adds a proper union method to ActiveRecord::Relation.
+description: UNIONs in ActiveRecord! Adds proper union and union_all methods to ActiveRecord::Relation.
 email:
 - plasticchicken@gmail.com
 executables: []
@@ -164,10 +164,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: UNIONs in ActiveRecord! Adds a proper union method to ActiveRecord::Relation.
+summary: UNIONs in ActiveRecord! Adds proper union and union_all methods to ActiveRecord::Relation.
 test_files:
 - spec/spec_helper.rb
 - spec/support/databases.rb