active_record_union 1.1.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e5aaf90d66c3e15eb7e2c225283b0c2790b146b
-  data.tar.gz: fb36ac1c86da58e19de86409e9bd3c35897e247f
+  metadata.gz: 3b6908e8b32e304532e3b8405712ade67fab7e52
+  data.tar.gz: 937298c6d470715b18510f2e317a7f3d735b2cf6
 SHA512:
-  metadata.gz: 3b0140dffec59d1214dc18c456dad0ff28c24f1262704ab7628af0f679dc08c5e30d9d8effcbff29fa4f6800894579b82f2663d15a1341b895512546f366c109
-  data.tar.gz: 9683ecd6bd506d3226a04ddb3abcd461a7a3adb0088d0f577069569965bac460480bf35f5dd26fcf966779a24a0f1cb32cf531e5c8600dea86769ec540416c26
+  metadata.gz: 8466c15bb3c268bbea28f49b3a85915e91f72bd43997462a4bd09a1da14ec9c85d5ca9621a6b7316ac04fe6949ccf4284bce854ed5b33c71bc492ca9bbd0cc9f
+  data.tar.gz: a99a9d9c0c19e332d9b0c357310d886c72c5b7f629be97a0d8e2dcdc8d90dcb1605960f3a44a8dacdfe0749dc7dfe6f2571ebe27d63a6bcb1970e7798447a88f

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+*.gemfile.lock
 InstalledFiles
 _yardoc
 coverage

data/.travis.yml

@@ -1,8 +1,11 @@
 language: ruby
 addons:
-  postgresql: "9.3"
-before_script:
-  - psql -c 'create database travis;' -U postgres # "travis" is the UNIX username, and therefore the default database name on connection
+  postgresql: "9.4"
 rvm:
-  - 2.1.2
-  - 2.0.0
+  - 2.3.6
+gemfile:
+  - rails_4_2.gemfile
+  - rails_5_0.gemfile
+  - rails_5_1.gemfile
+  - rails_5_2.gemfile
+script: bundle exec rspec

data/README.md

@@ -7,6 +7,18 @@ 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:
@@ -55,7 +67,7 @@ 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
+) "posts"
 ```
 
 Because the `union` method returns another `ActiveRecord::Relation`, we can run further queries on the union.
@@ -68,7 +80,7 @@ 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)
+) "posts"  WHERE "posts"."id" IN (6, 7)
 ```
 
 The `union` method can also accept anything that `where` does.
@@ -92,10 +104,10 @@ SELECT "posts".* FROM (
     SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 1
     UNION
     SELECT "posts".* FROM "posts"  WHERE "posts"."user_id" = 2
-  ) posts
+  ) "posts"
   UNION
   SELECT "posts".* FROM "posts"  WHERE (published_at < '2014-07-19 16:12:45.882648')
-) posts
+) "posts"
 ```
 
 ### UNION ALL
@@ -110,14 +122,14 @@ SELECT "posts".* FROM (
   SELECT "posts".* FROM "posts" WHERE "posts"."user_id" = 1
   UNION ALL
   SELECT "posts".* FROM "posts" WHERE "posts"."user_id" = 2
-) posts
+) "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.
+1. ActiveRecordUnion will 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
@@ -174,6 +186,16 @@ This is a gem not a Rails pull request because the standard of code quality for
 
 ## Changelog
 
+**1.3.0** - January 14, 2018
+  - Ready for Rails 5.2! Updates provided by [@glebm](https://github.com/glebm).
+
+**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).
@@ -190,7 +212,11 @@ This public domain dedication follows the the CC0 1.0 at https://creativecommons
 
 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`
+3. Run the tests:
+  1. Install MySQL and PostgreSQL.
+  2. You need to be able to connect to a local MySQL and Postgres database as the default user, so the specs can create a `test_active_record_union` database. From a vanilla install of MariaDB from Homebrew, this just works. For Postgres installed by Homebrew, you may need to run `$ echo "create database my_computer_user_name;" | psql postgres` since the initial database created by Homebrew is named "postgres" but PG defaults to connecting to a database named after your username.
+  3. Run `rake` to test with all supported Rails versions. All needed dependencies will be installed via Bundler (`gem install bundler` if you happen not to have Bundler yet).
+  4. Run `rake test_rails_4_2` or `rake test_rails_5_2` etc. 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`)

data/Rakefile

@@ -1,8 +1,61 @@
 require "bundler/gem_tasks"
 
-task :default => :spec
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :test_all_gemfiles
 
-desc "Run the tests"
-task :spec do
-  exec("bundle exec rspec")
+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/lib/active_record_union/active_record/relation/union.rb

@@ -3,46 +3,79 @@ module ActiveRecord
     module Union
 
       SET_OPERATION_TO_AREL_CLASS = {
-        "UNION"     => Arel::Nodes::Union,
-        "UNION ALL" => Arel::Nodes::UnionAll
+        union:     Arel::Nodes::Union,
+        union_all: Arel::Nodes::UnionAll
       }
 
-      def  union(relation_or_where_arg, *args)
-        set_operation("UNION", relation_or_where_arg, *args)
+      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)
+      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
+        other = if args.empty? && relation_or_where_arg.is_a?(Relation)
+                  relation_or_where_arg
+                else
+                  @klass.where(relation_or_where_arg, *args)
+                end
 
         verify_relations_for_set_operation!(operation, self, other)
 
+        left = self.arel.ast
+        right = other.arel.ast
+
         # 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.visitor
-          left, right = self.ast, other.ast
-        else
-          left, right = Arel::Nodes::Grouping.new(self.ast), Arel::Nodes::Grouping.new(other.ast)
+        # but SQLite does not allow parens around the subqueries
+        unless self.connection.visitor.is_a?(Arel::Visitors::SQLite)
+          left = Arel::Nodes::Grouping.new(left)
+          right = Arel::Nodes::Grouping.new(right)
         end
 
-        set = SET_OPERATION_TO_AREL_CLASS[operation].new(left, right)
-        from = Arel::Nodes::TableAlias.new(
-          set,
-          Arel::Nodes::SqlLiteral.new(@klass.arel_table.name)
-        )
+        set  = SET_OPERATION_TO_AREL_CLASS[operation].new(left, right)
+        from = Arel::Nodes::TableAlias.new(set, @klass.arel_table.name)
+        build_union_relation(from, other)
+      end
 
-        relation = @klass.unscoped.from(from)
-        relation.bind_values = self.bind_values + other.bind_values
-        relation
+      if ActiveRecord.gem_version >= Gem::Version.new('5.2.0.beta2')
+        # Since Rails 5.2, binds are maintained only in the Arel AST.
+        def build_union_relation(arel_table_alias, _other)
+          @klass.unscoped.from(arel_table_alias)
+        end
+      elsif ActiveRecord::VERSION::MAJOR >= 5
+        # In Rails >= 5.0, < 5.2, binds are maintained only in ActiveRecord
+        # relations and clauses.
+        def build_union_relation(arel_table_alias, other)
+          relation = @klass.unscoped.spawn
+          relation.from_clause =
+            UnionFromClause.new(arel_table_alias, nil,
+                                self.bound_attributes + other.bound_attributes)
+          relation
+        end
+
+        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
+      else
+        # In Rails 4.x, binds are maintained in both ActiveRecord relations and
+        # clauses and also in their Arel ASTs.
+        def build_union_relation(arel_table_alias, other)
+          relation = @klass.unscoped.from(arel_table_alias)
+          relation.bind_values = self.arel.bind_values + self.bind_values +
+                                 other.arel.bind_values + other.bind_values
+          relation
+        end
       end
 
       def verify_relations_for_set_operation!(operation, *relations)

data/lib/active_record_union/version.rb

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

data/rails_4_2.gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec
+
+gem 'rails', '~> 4.2.7'
+
+# On Rails < 5.2, only pg < v1 is supported. See:
+# https://github.com/rails/rails/pull/31671
+# https://bitbucket.org/ged/ruby-pg/issues/270/pg-100-x64-mingw32-rails-server-not-start
+gem 'pg', '~> 0.21'

data/rails_5_0.gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec
+
+gem 'rails', '~> 5.0.0'
+
+# On Rails < 5.2, only pg < v1 is supported. See:
+# https://github.com/rails/rails/pull/31671
+# https://bitbucket.org/ged/ruby-pg/issues/270/pg-100-x64-mingw32-rails-server-not-start
+gem 'pg', '~> 0.21'

data/rails_5_1.gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec
+
+gem 'rails', '~> 5.1.0'
+
+# On Rails < 5.2, only pg < v1 is supported. See:
+# https://github.com/rails/rails/pull/31671
+# https://bitbucket.org/ged/ruby-pg/issues/270/pg-100-x64-mingw32-rails-server-not-start
+gem 'pg', '~> 0.21'

data/rails_5_2.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_record_union.gemspec
+gemspec
+
+# pg v1.0+ compatibility, https://github.com/rails/rails/pull/31671:
+gem 'rails', '~> 5.2.0.beta2', git: 'https://github.com/rails/rails', ref: 'f1af27fd9d9101684b26d0dcf2028859d67bec1f'

data/spec/support/databases.rb

@@ -35,12 +35,14 @@ module Databases
 
   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

data/spec/support/models.rb

@@ -3,10 +3,12 @@ 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

data/spec/union_spec.rb

@@ -1,6 +1,9 @@
-require 'spec_helper'
+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)
@@ -26,55 +29,84 @@ describe ActiveRecord::Relation do
     end
 
     it "works" do
-      union = User.new(id: 1).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))
 
       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"
+        "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 > '2014-07-19 00:00:00.000000') ) posts"
+        "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.gem_version >= Gem::Version.new('5.2.0.beta2')
+        relation.arel_table.class.engine.connection.visitor.accept(
+          relation.arel.ast, Arel::Collectors::Bind.new
+        ).value.map(&:value)
+      elsif 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)
-      bind_values = union.bind_values.map { |column, value| value }
+
+      # 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.utc(2014, 7, 19, 0, 0, 0)).union(User.new(id: 1).posts)
+      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 < '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"
+        "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
-      def union
+      let :union do
         User.new(id: 1).posts.order(:created_at).union(
-          Post.where("created_at > ?", Time.utc(2014, 7, 19, 0, 0, 0)).order(:created_at)
+          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 > '2014-07-19 00:00:00.000000') ORDER BY \"posts\".\"created_at\" ASC ) posts ORDER BY \"posts\".\"created_at\" ASC"
+            "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
@@ -84,7 +116,7 @@ describe ActiveRecord::Relation 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 > '2014-07-19 00:00:00.000000') ORDER BY \"posts\".\"created_at\" ASC) ) posts ORDER BY \"posts\".\"created_at\" ASC"
+              "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
@@ -95,7 +127,7 @@ describe ActiveRecord::Relation 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 > '2014-07-19 00:00:00.000000')  ORDER BY \"posts\".\"created_at\" ASC) ) posts   ORDER BY \"posts\".\"created_at\" ASC"
+              "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
@@ -108,34 +140,37 @@ describe ActiveRecord::Relation 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"
+          "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.utc(2014, 7, 19, 0, 0, 0))
+        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 > '2014-07-19 00:00:00.000000') ) posts"
+          "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"
+          "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.utc(2014, 7, 19, 0, 0, 0)))
+      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 > '2014-07-19 00:00:00.000000') ) posts"
+        "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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_union
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Brian Hempel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-30 00:00:00.000000000 Z
+date: 2018-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -131,7 +131,6 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
-- Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -140,6 +139,10 @@ files:
 - lib/active_record_union.rb
 - lib/active_record_union/active_record/relation/union.rb
 - lib/active_record_union/version.rb
+- rails_4_2.gemfile
+- rails_5_0.gemfile
+- rails_5_1.gemfile
+- rails_5_2.gemfile
 - spec/spec_helper.rb
 - spec/support/databases.rb
 - spec/support/models.rb
@@ -164,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: UNIONs in ActiveRecord! Adds proper union and union_all methods to ActiveRecord::Relation.

data/Gemfile

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