kotovalexarian-likes-github
/
rails--rails
mirror of https://github.com/rails/rails.git
1
0
Fork 0
Code Releases Activity

Address to the warning "DEPRECATED: global use of assertion methods" 

This addresses to the warning "DEPRECATED: global use of assertion
methods" which is introduced in minitest v5.12.0.

e6bc448573

https://buildkite.com/rails/rails/builds/64121#880aecf2-849f-4603-95f1-228784c7d3f4/1003-1010
This commit is contained in:
Ryuta Kamizono 2019-10-04 17:16:33 +09:00
parent a0550aee11
commit 6158b83d2a
32 changed files with 553 additions and 551 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Gemfile.lock
View File

@ -317,7 +317,7 @@ GEM
mini_magick (4.9.5) mini_magick (4.9.5)
mini_mime (1.0.1) mini_mime (1.0.1)
mini_portile2 (2.4.0) mini_portile2 (2.4.0)
minitest (5.11.3) minitest (5.12.2)
minitest-bisect (1.4.0) minitest-bisect (1.4.0)
minitest-server (~> 1.0) minitest-server (~> 1.0)
path_expander (~> 1.0) path_expander (~> 1.0)
@ -340,6 +340,8 @@ GEM
mustache (1.1.0) mustache (1.1.0)
mustermann (1.0.3) mustermann (1.0.3)
mysql2 (0.5.2) mysql2 (0.5.2)
mysql2 (0.5.2-x64-mingw32)
mysql2 (0.5.2-x86-mingw32)
nio4r (2.4.0) nio4r (2.4.0)
nio4r (2.4.0-java) nio4r (2.4.0-java)
nokogiri (1.10.4) nokogiri (1.10.4)

250
activerecord/test/cases/arel/attributes/attribute_test.rb
View File

@ -9,14 +9,14 @@ module Arel
describe "#not_eq" do describe "#not_eq" do
it "should create a NotEqual node" do it "should create a NotEqual node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].not_eq(10).must_be_kind_of Nodes::NotEqual _(relation[:id].not_eq(10)).must_be_kind_of Nodes::NotEqual
end end
it "should generate != in sql" do it "should generate != in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_eq(10) mgr.where relation[:id].not_eq(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" != 10 SELECT "users"."id" FROM "users" WHERE "users"."id" != 10
} }
end end
@ -25,7 +25,7 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_eq(nil) mgr.where relation[:id].not_eq(nil)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL
} }
end end
@ -34,14 +34,14 @@ module Arel
describe "#not_eq_any" do describe "#not_eq_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].not_eq_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].not_eq_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_eq_any([1, 2]) mgr.where relation[:id].not_eq_any([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 OR "users"."id" != 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 OR "users"."id" != 2)
} }
end end
@ -50,14 +50,14 @@ module Arel
describe "#not_eq_all" do describe "#not_eq_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].not_eq_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].not_eq_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_eq_all([1, 2]) mgr.where relation[:id].not_eq_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 AND "users"."id" != 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" != 1 AND "users"."id" != 2)
} }
end end
@ -66,14 +66,14 @@ module Arel
describe "#gt" do describe "#gt" do
it "should create a GreaterThan node" do it "should create a GreaterThan node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].gt(10).must_be_kind_of Nodes::GreaterThan _(relation[:id].gt(10)).must_be_kind_of Nodes::GreaterThan
end end
it "should generate > in sql" do it "should generate > in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].gt(10) mgr.where relation[:id].gt(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" > 10 SELECT "users"."id" FROM "users" WHERE "users"."id" > 10
} }
end end
@ -84,7 +84,7 @@ module Arel
avg = users.project(users[:karma].average) avg = users.project(users[:karma].average)
mgr = users.project(Arel.star).where(users[:karma].gt(avg)) mgr = users.project(Arel.star).where(users[:karma].gt(avg))
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") FROM "users") SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") FROM "users")
} }
end end
@ -93,25 +93,25 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].gt("fake_name") mgr.where relation[:name].gt("fake_name")
mgr.to_sql.must_match %{"users"."name" > 'fake_name'} _(mgr.to_sql).must_match %{"users"."name" > 'fake_name'}
current_time = ::Time.now current_time = ::Time.now
mgr.where relation[:created_at].gt(current_time) mgr.where relation[:created_at].gt(current_time)
mgr.to_sql.must_match %{"users"."created_at" > '#{current_time}'} _(mgr.to_sql).must_match %{"users"."created_at" > '#{current_time}'}
end end
end end
describe "#gt_any" do describe "#gt_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].gt_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].gt_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].gt_any([1, 2]) mgr.where relation[:id].gt_any([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 OR "users"."id" > 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 OR "users"."id" > 2)
} }
end end
@ -120,14 +120,14 @@ module Arel
describe "#gt_all" do describe "#gt_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].gt_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].gt_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].gt_all([1, 2]) mgr.where relation[:id].gt_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 AND "users"."id" > 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" > 1 AND "users"."id" > 2)
} }
end end
@ -136,14 +136,14 @@ module Arel
describe "#gteq" do describe "#gteq" do
it "should create a GreaterThanOrEqual node" do it "should create a GreaterThanOrEqual node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].gteq(10).must_be_kind_of Nodes::GreaterThanOrEqual _(relation[:id].gteq(10)).must_be_kind_of Nodes::GreaterThanOrEqual
end end
it "should generate >= in sql" do it "should generate >= in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].gteq(10) mgr.where relation[:id].gteq(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10 SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
} }
end end
@ -152,25 +152,25 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].gteq("fake_name") mgr.where relation[:name].gteq("fake_name")
mgr.to_sql.must_match %{"users"."name" >= 'fake_name'} _(mgr.to_sql).must_match %{"users"."name" >= 'fake_name'}
current_time = ::Time.now current_time = ::Time.now
mgr.where relation[:created_at].gteq(current_time) mgr.where relation[:created_at].gteq(current_time)
mgr.to_sql.must_match %{"users"."created_at" >= '#{current_time}'} _(mgr.to_sql).must_match %{"users"."created_at" >= '#{current_time}'}
end end
end end
describe "#gteq_any" do describe "#gteq_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].gteq_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].gteq_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].gteq_any([1, 2]) mgr.where relation[:id].gteq_any([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 OR "users"."id" >= 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 OR "users"."id" >= 2)
} }
end end
@ -179,14 +179,14 @@ module Arel
describe "#gteq_all" do describe "#gteq_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].gteq_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].gteq_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].gteq_all([1, 2]) mgr.where relation[:id].gteq_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 AND "users"."id" >= 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" >= 1 AND "users"."id" >= 2)
} }
end end
@ -195,14 +195,14 @@ module Arel
describe "#lt" do describe "#lt" do
it "should create a LessThan node" do it "should create a LessThan node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].lt(10).must_be_kind_of Nodes::LessThan _(relation[:id].lt(10)).must_be_kind_of Nodes::LessThan
end end
it "should generate < in sql" do it "should generate < in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].lt(10) mgr.where relation[:id].lt(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" < 10 SELECT "users"."id" FROM "users" WHERE "users"."id" < 10
} }
end end
@ -211,25 +211,25 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].lt("fake_name") mgr.where relation[:name].lt("fake_name")
mgr.to_sql.must_match %{"users"."name" < 'fake_name'} _(mgr.to_sql).must_match %{"users"."name" < 'fake_name'}
current_time = ::Time.now current_time = ::Time.now
mgr.where relation[:created_at].lt(current_time) mgr.where relation[:created_at].lt(current_time)
mgr.to_sql.must_match %{"users"."created_at" < '#{current_time}'} _(mgr.to_sql).must_match %{"users"."created_at" < '#{current_time}'}
end end
end end
describe "#lt_any" do describe "#lt_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].lt_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].lt_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].lt_any([1, 2]) mgr.where relation[:id].lt_any([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 OR "users"."id" < 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 OR "users"."id" < 2)
} }
end end
@ -238,14 +238,14 @@ module Arel
describe "#lt_all" do describe "#lt_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].lt_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].lt_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].lt_all([1, 2]) mgr.where relation[:id].lt_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 AND "users"."id" < 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" < 1 AND "users"."id" < 2)
} }
end end
@ -254,14 +254,14 @@ module Arel
describe "#lteq" do describe "#lteq" do
it "should create a LessThanOrEqual node" do it "should create a LessThanOrEqual node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].lteq(10).must_be_kind_of Nodes::LessThanOrEqual _(relation[:id].lteq(10)).must_be_kind_of Nodes::LessThanOrEqual
end end
it "should generate <= in sql" do it "should generate <= in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].lteq(10) mgr.where relation[:id].lteq(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10 SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10
} }
end end
@ -270,25 +270,25 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].lteq("fake_name") mgr.where relation[:name].lteq("fake_name")
mgr.to_sql.must_match %{"users"."name" <= 'fake_name'} _(mgr.to_sql).must_match %{"users"."name" <= 'fake_name'}
current_time = ::Time.now current_time = ::Time.now
mgr.where relation[:created_at].lteq(current_time) mgr.where relation[:created_at].lteq(current_time)
mgr.to_sql.must_match %{"users"."created_at" <= '#{current_time}'} _(mgr.to_sql).must_match %{"users"."created_at" <= '#{current_time}'}
end end
end end
describe "#lteq_any" do describe "#lteq_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].lteq_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].lteq_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].lteq_any([1, 2]) mgr.where relation[:id].lteq_any([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 OR "users"."id" <= 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 OR "users"."id" <= 2)
} }
end end
@ -297,14 +297,14 @@ module Arel
describe "#lteq_all" do describe "#lteq_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].lteq_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].lteq_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].lteq_all([1, 2]) mgr.where relation[:id].lteq_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 AND "users"."id" <= 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" <= 1 AND "users"."id" <= 2)
} }
end end
@ -313,13 +313,13 @@ module Arel
describe "#average" do describe "#average" do
it "should create a AVG node" do it "should create a AVG node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].average.must_be_kind_of Nodes::Avg _(relation[:id].average).must_be_kind_of Nodes::Avg
end end
it "should generate the proper SQL" do it "should generate the proper SQL" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id].average mgr = relation.project relation[:id].average
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT AVG("users"."id") SELECT AVG("users"."id")
FROM "users" FROM "users"
} }
@ -329,13 +329,13 @@ module Arel
describe "#maximum" do describe "#maximum" do
it "should create a MAX node" do it "should create a MAX node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].maximum.must_be_kind_of Nodes::Max _(relation[:id].maximum).must_be_kind_of Nodes::Max
end end
it "should generate proper SQL" do it "should generate proper SQL" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id].maximum mgr = relation.project relation[:id].maximum
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT MAX("users"."id") SELECT MAX("users"."id")
FROM "users" FROM "users"
} }
@ -345,13 +345,13 @@ module Arel
describe "#minimum" do describe "#minimum" do
it "should create a Min node" do it "should create a Min node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].minimum.must_be_kind_of Nodes::Min _(relation[:id].minimum).must_be_kind_of Nodes::Min
end end
it "should generate proper SQL" do it "should generate proper SQL" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id].minimum mgr = relation.project relation[:id].minimum
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT MIN("users"."id") SELECT MIN("users"."id")
FROM "users" FROM "users"
} }
@ -361,13 +361,13 @@ module Arel
describe "#sum" do describe "#sum" do
it "should create a SUM node" do it "should create a SUM node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].sum.must_be_kind_of Nodes::Sum _(relation[:id].sum).must_be_kind_of Nodes::Sum
end end
it "should generate the proper SQL" do it "should generate the proper SQL" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id].sum mgr = relation.project relation[:id].sum
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT SUM("users"."id") SELECT SUM("users"."id")
FROM "users" FROM "users"
} }
@ -377,14 +377,14 @@ module Arel
describe "#count" do describe "#count" do
it "should return a count node" do it "should return a count node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].count.must_be_kind_of Nodes::Count _(relation[:id].count).must_be_kind_of Nodes::Count
end end
it "should take a distinct param" do it "should take a distinct param" do
relation = Table.new(:users) relation = Table.new(:users)
count = relation[:id].count(nil) count = relation[:id].count(nil)
count.must_be_kind_of Nodes::Count _(count).must_be_kind_of Nodes::Count
count.distinct.must_be_nil _(count.distinct).must_be_nil
end end
end end
@ -392,16 +392,16 @@ module Arel
it "should return an equality node" do it "should return an equality node" do
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
equality = attribute.eq 1 equality = attribute.eq 1
equality.left.must_equal attribute _(equality.left).must_equal attribute
equality.right.val.must_equal 1 _(equality.right.val).must_equal 1
equality.must_be_kind_of Nodes::Equality _(equality).must_be_kind_of Nodes::Equality
end end
it "should generate = in sql" do it "should generate = in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].eq(10) mgr.where relation[:id].eq(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" = 10 SELECT "users"."id" FROM "users" WHERE "users"."id" = 10
} }
end end
@ -410,7 +410,7 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].eq(nil) mgr.where relation[:id].eq(nil)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" IS NULL SELECT "users"."id" FROM "users" WHERE "users"."id" IS NULL
} }
end end
@ -419,14 +419,14 @@ module Arel
describe "#eq_any" do describe "#eq_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].eq_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].eq_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].eq_any([1, 2]) mgr.where relation[:id].eq_any([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 OR "users"."id" = 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 OR "users"."id" = 2)
} }
end end
@ -436,21 +436,21 @@ module Arel
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
values = [1, 2] values = [1, 2]
mgr.where relation[:id].eq_any(values) mgr.where relation[:id].eq_any(values)
values.must_equal [1, 2] _(values).must_equal [1, 2]
end end
end end
describe "#eq_all" do describe "#eq_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].eq_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].eq_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].eq_all([1, 2]) mgr.where relation[:id].eq_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
} }
end end
@ -460,21 +460,21 @@ module Arel
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
values = [1, 2] values = [1, 2]
mgr.where relation[:id].eq_all(values) mgr.where relation[:id].eq_all(values)
values.must_equal [1, 2] _(values).must_equal [1, 2]
end end
end end
describe "#matches" do describe "#matches" do
it "should create a Matches node" do it "should create a Matches node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:name].matches("%bacon%").must_be_kind_of Nodes::Matches _(relation[:name].matches("%bacon%")).must_be_kind_of Nodes::Matches
end end
it "should generate LIKE in sql" do it "should generate LIKE in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].matches("%bacon%") mgr.where relation[:name].matches("%bacon%")
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."name" LIKE '%bacon%' SELECT "users"."id" FROM "users" WHERE "users"."name" LIKE '%bacon%'
} }
end end
@ -483,14 +483,14 @@ module Arel
describe "#matches_any" do describe "#matches_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:name].matches_any(["%chunky%", "%bacon%"]).must_be_kind_of Nodes::Grouping _(relation[:name].matches_any(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].matches_any(["%chunky%", "%bacon%"]) mgr.where relation[:name].matches_any(["%chunky%", "%bacon%"])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' OR "users"."name" LIKE '%bacon%') SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' OR "users"."name" LIKE '%bacon%')
} }
end end
@ -499,14 +499,14 @@ module Arel
describe "#matches_all" do describe "#matches_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:name].matches_all(["%chunky%", "%bacon%"]).must_be_kind_of Nodes::Grouping _(relation[:name].matches_all(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].matches_all(["%chunky%", "%bacon%"]) mgr.where relation[:name].matches_all(["%chunky%", "%bacon%"])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' AND "users"."name" LIKE '%bacon%') SELECT "users"."id" FROM "users" WHERE ("users"."name" LIKE '%chunky%' AND "users"."name" LIKE '%bacon%')
} }
end end
@ -515,14 +515,14 @@ module Arel
describe "#does_not_match" do describe "#does_not_match" do
it "should create a DoesNotMatch node" do it "should create a DoesNotMatch node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:name].does_not_match("%bacon%").must_be_kind_of Nodes::DoesNotMatch _(relation[:name].does_not_match("%bacon%")).must_be_kind_of Nodes::DoesNotMatch
end end
it "should generate NOT LIKE in sql" do it "should generate NOT LIKE in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].does_not_match("%bacon%") mgr.where relation[:name].does_not_match("%bacon%")
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."name" NOT LIKE '%bacon%' SELECT "users"."id" FROM "users" WHERE "users"."name" NOT LIKE '%bacon%'
} }
end end
@ -531,14 +531,14 @@ module Arel
describe "#does_not_match_any" do describe "#does_not_match_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:name].does_not_match_any(["%chunky%", "%bacon%"]).must_be_kind_of Nodes::Grouping _(relation[:name].does_not_match_any(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].does_not_match_any(["%chunky%", "%bacon%"]) mgr.where relation[:name].does_not_match_any(["%chunky%", "%bacon%"])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' OR "users"."name" NOT LIKE '%bacon%') SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' OR "users"."name" NOT LIKE '%bacon%')
} }
end end
@ -547,14 +547,14 @@ module Arel
describe "#does_not_match_all" do describe "#does_not_match_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:name].does_not_match_all(["%chunky%", "%bacon%"]).must_be_kind_of Nodes::Grouping _(relation[:name].does_not_match_all(["%chunky%", "%bacon%"])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:name].does_not_match_all(["%chunky%", "%bacon%"]) mgr.where relation[:name].does_not_match_all(["%chunky%", "%bacon%"])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' AND "users"."name" NOT LIKE '%bacon%') SELECT "users"."id" FROM "users" WHERE ("users"."name" NOT LIKE '%chunky%' AND "users"."name" NOT LIKE '%bacon%')
} }
end end
@ -565,7 +565,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(1..3) node = attribute.between(1..3)
node.must_equal Nodes::Between.new( _(node).must_equal Nodes::Between.new(
attribute, attribute,
Nodes::And.new([ Nodes::And.new([
Nodes::Casted.new(1, attribute), Nodes::Casted.new(1, attribute),
@ -578,7 +578,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(-::Float::INFINITY..3) node = attribute.between(-::Float::INFINITY..3)
node.must_equal Nodes::LessThanOrEqual.new( _(node).must_equal Nodes::LessThanOrEqual.new(
attribute, attribute,
Nodes::Casted.new(3, attribute) Nodes::Casted.new(3, attribute)
) )
@ -588,7 +588,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(quoted_range(-::Float::INFINITY, 3, false)) node = attribute.between(quoted_range(-::Float::INFINITY, 3, false))
node.must_equal Nodes::LessThanOrEqual.new( _(node).must_equal Nodes::LessThanOrEqual.new(
attribute, attribute,
Nodes::Quoted.new(3) Nodes::Quoted.new(3)
) )
@ -598,7 +598,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(-::Float::INFINITY...3) node = attribute.between(-::Float::INFINITY...3)
node.must_equal Nodes::LessThan.new( _(node).must_equal Nodes::LessThan.new(
attribute, attribute,
Nodes::Casted.new(3, attribute) Nodes::Casted.new(3, attribute)
) )
@ -608,7 +608,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(quoted_range(-::Float::INFINITY, 3, true)) node = attribute.between(quoted_range(-::Float::INFINITY, 3, true))
node.must_equal Nodes::LessThan.new( _(node).must_equal Nodes::LessThan.new(
attribute, attribute,
Nodes::Quoted.new(3) Nodes::Quoted.new(3)
) )
@ -618,21 +618,21 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(-::Float::INFINITY..::Float::INFINITY) node = attribute.between(-::Float::INFINITY..::Float::INFINITY)
node.must_equal Nodes::NotIn.new(attribute, []) _(node).must_equal Nodes::NotIn.new(attribute, [])
end end
it "can be constructed with a quoted infinite range" do it "can be constructed with a quoted infinite range" do
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false)) node = attribute.between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false))
node.must_equal Nodes::NotIn.new(attribute, []) _(node).must_equal Nodes::NotIn.new(attribute, [])
end end
it "can be constructed with a range ending at Infinity" do it "can be constructed with a range ending at Infinity" do
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(0..::Float::INFINITY) node = attribute.between(0..::Float::INFINITY)
node.must_equal Nodes::GreaterThanOrEqual.new( _(node).must_equal Nodes::GreaterThanOrEqual.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
) )
@ -643,7 +643,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(eval("..0")) # eval for backwards compatibility node = attribute.between(eval("..0")) # eval for backwards compatibility
node.must_equal Nodes::LessThanOrEqual.new( _(node).must_equal Nodes::LessThanOrEqual.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
) )
@ -655,7 +655,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(eval("0..")) # Use eval for compatibility with Ruby < 2.6 parser node = attribute.between(eval("0..")) # Use eval for compatibility with Ruby < 2.6 parser
node.must_equal Nodes::GreaterThanOrEqual.new( _(node).must_equal Nodes::GreaterThanOrEqual.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
) )
@ -666,7 +666,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(quoted_range(0, ::Float::INFINITY, false)) node = attribute.between(quoted_range(0, ::Float::INFINITY, false))
node.must_equal Nodes::GreaterThanOrEqual.new( _(node).must_equal Nodes::GreaterThanOrEqual.new(
attribute, attribute,
Nodes::Quoted.new(0) Nodes::Quoted.new(0)
) )
@ -676,7 +676,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.between(0...3) node = attribute.between(0...3)
node.must_equal Nodes::And.new([ _(node).must_equal Nodes::And.new([
Nodes::GreaterThanOrEqual.new( Nodes::GreaterThanOrEqual.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
@ -698,14 +698,14 @@ module Arel
node = attribute.in(mgr) node = attribute.in(mgr)
node.must_equal Nodes::In.new(attribute, mgr.ast) _(node).must_equal Nodes::In.new(attribute, mgr.ast)
end end
it "can be constructed with a list" do it "can be constructed with a list" do
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.in([1, 2, 3]) node = attribute.in([1, 2, 3])
node.must_equal Nodes::In.new( _(node).must_equal Nodes::In.new(
attribute, attribute,
[ [
Nodes::Casted.new(1, attribute), Nodes::Casted.new(1, attribute),
@ -720,7 +720,7 @@ module Arel
random_object = Object.new random_object = Object.new
node = attribute.in(random_object) node = attribute.in(random_object)
node.must_equal Nodes::In.new( _(node).must_equal Nodes::In.new(
attribute, attribute,
Nodes::Casted.new(random_object, attribute) Nodes::Casted.new(random_object, attribute)
) )
@ -730,7 +730,7 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].in([1, 2, 3]) mgr.where relation[:id].in([1, 2, 3])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" IN (1, 2, 3) SELECT "users"."id" FROM "users" WHERE "users"."id" IN (1, 2, 3)
} }
end end
@ -739,14 +739,14 @@ module Arel
describe "#in_any" do describe "#in_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].in_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].in_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].in_any([[1, 2], [3, 4]]) mgr.where relation[:id].in_any([[1, 2], [3, 4]])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) OR "users"."id" IN (3, 4)) SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) OR "users"."id" IN (3, 4))
} }
end end
@ -755,14 +755,14 @@ module Arel
describe "#in_all" do describe "#in_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].in_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].in_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].in_all([[1, 2], [3, 4]]) mgr.where relation[:id].in_all([[1, 2], [3, 4]])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) AND "users"."id" IN (3, 4)) SELECT "users"."id" FROM "users" WHERE ("users"."id" IN (1, 2) AND "users"."id" IN (3, 4))
} }
end end
@ -773,7 +773,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(1..3) node = attribute.not_between(1..3)
node.must_equal Nodes::Grouping.new( _(node).must_equal Nodes::Grouping.new(
Nodes::Or.new( Nodes::Or.new(
Nodes::LessThan.new( Nodes::LessThan.new(
attribute, attribute,
@ -791,7 +791,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(-::Float::INFINITY..3) node = attribute.not_between(-::Float::INFINITY..3)
node.must_equal Nodes::GreaterThan.new( _(node).must_equal Nodes::GreaterThan.new(
attribute, attribute,
Nodes::Casted.new(3, attribute) Nodes::Casted.new(3, attribute)
) )
@ -801,7 +801,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(quoted_range(-::Float::INFINITY, 3, false)) node = attribute.not_between(quoted_range(-::Float::INFINITY, 3, false))
node.must_equal Nodes::GreaterThan.new( _(node).must_equal Nodes::GreaterThan.new(
attribute, attribute,
Nodes::Quoted.new(3) Nodes::Quoted.new(3)
) )
@ -811,7 +811,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(-::Float::INFINITY...3) node = attribute.not_between(-::Float::INFINITY...3)
node.must_equal Nodes::GreaterThanOrEqual.new( _(node).must_equal Nodes::GreaterThanOrEqual.new(
attribute, attribute,
Nodes::Casted.new(3, attribute) Nodes::Casted.new(3, attribute)
) )
@ -821,7 +821,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(quoted_range(-::Float::INFINITY, 3, true)) node = attribute.not_between(quoted_range(-::Float::INFINITY, 3, true))
node.must_equal Nodes::GreaterThanOrEqual.new( _(node).must_equal Nodes::GreaterThanOrEqual.new(
attribute, attribute,
Nodes::Quoted.new(3) Nodes::Quoted.new(3)
) )
@ -831,21 +831,21 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(-::Float::INFINITY..::Float::INFINITY) node = attribute.not_between(-::Float::INFINITY..::Float::INFINITY)
node.must_equal Nodes::In.new(attribute, []) _(node).must_equal Nodes::In.new(attribute, [])
end end
it "can be constructed with a quoted infinite range" do it "can be constructed with a quoted infinite range" do
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false)) node = attribute.not_between(quoted_range(-::Float::INFINITY, ::Float::INFINITY, false))
node.must_equal Nodes::In.new(attribute, []) _(node).must_equal Nodes::In.new(attribute, [])
end end
it "can be constructed with a range ending at Infinity" do it "can be constructed with a range ending at Infinity" do
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(0..::Float::INFINITY) node = attribute.not_between(0..::Float::INFINITY)
node.must_equal Nodes::LessThan.new( _(node).must_equal Nodes::LessThan.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
) )
@ -856,7 +856,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(eval("..0")) # eval for backwards compatibility node = attribute.not_between(eval("..0")) # eval for backwards compatibility
node.must_equal Nodes::GreaterThan.new( _(node).must_equal Nodes::GreaterThan.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
) )
@ -868,7 +868,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(eval("0..")) # Use eval for compatibility with Ruby < 2.6 parser node = attribute.not_between(eval("0..")) # Use eval for compatibility with Ruby < 2.6 parser
node.must_equal Nodes::LessThan.new( _(node).must_equal Nodes::LessThan.new(
attribute, attribute,
Nodes::Casted.new(0, attribute) Nodes::Casted.new(0, attribute)
) )
@ -879,7 +879,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(quoted_range(0, ::Float::INFINITY, false)) node = attribute.not_between(quoted_range(0, ::Float::INFINITY, false))
node.must_equal Nodes::LessThan.new( _(node).must_equal Nodes::LessThan.new(
attribute, attribute,
Nodes::Quoted.new(0) Nodes::Quoted.new(0)
) )
@ -889,7 +889,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_between(0...3) node = attribute.not_between(0...3)
node.must_equal Nodes::Grouping.new( _(node).must_equal Nodes::Grouping.new(
Nodes::Or.new( Nodes::Or.new(
Nodes::LessThan.new( Nodes::LessThan.new(
attribute, attribute,
@ -913,7 +913,7 @@ module Arel
node = attribute.not_in(mgr) node = attribute.not_in(mgr)
node.must_equal Nodes::NotIn.new(attribute, mgr.ast) _(node).must_equal Nodes::NotIn.new(attribute, mgr.ast)
end end
it "can be constructed with a Union" do it "can be constructed with a Union" do
@ -923,7 +923,7 @@ module Arel
union = mgr1.union(mgr2) union = mgr1.union(mgr2)
node = relation[:id].in(union) node = relation[:id].in(union)
node.to_sql.must_be_like %{ _(node.to_sql).must_be_like %{
"users"."id" IN (( SELECT "users"."id" FROM "users" UNION SELECT "users"."id" FROM "users" )) "users"."id" IN (( SELECT "users"."id" FROM "users" UNION SELECT "users"."id" FROM "users" ))
} }
end end
@ -932,7 +932,7 @@ module Arel
attribute = Attribute.new nil, nil attribute = Attribute.new nil, nil
node = attribute.not_in([1, 2, 3]) node = attribute.not_in([1, 2, 3])
node.must_equal Nodes::NotIn.new( _(node).must_equal Nodes::NotIn.new(
attribute, attribute,
[ [
Nodes::Casted.new(1, attribute), Nodes::Casted.new(1, attribute),
@ -947,7 +947,7 @@ module Arel
random_object = Object.new random_object = Object.new
node = attribute.not_in(random_object) node = attribute.not_in(random_object)
node.must_equal Nodes::NotIn.new( _(node).must_equal Nodes::NotIn.new(
attribute, attribute,
Nodes::Casted.new(random_object, attribute) Nodes::Casted.new(random_object, attribute)
) )
@ -957,7 +957,7 @@ module Arel
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_in([1, 2, 3]) mgr.where relation[:id].not_in([1, 2, 3])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" NOT IN (1, 2, 3) SELECT "users"."id" FROM "users" WHERE "users"."id" NOT IN (1, 2, 3)
} }
end end
@ -966,14 +966,14 @@ module Arel
describe "#not_in_any" do describe "#not_in_any" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].not_in_any([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].not_in_any([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ORs in sql" do it "should generate ORs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_in_any([[1, 2], [3, 4]]) mgr.where relation[:id].not_in_any([[1, 2], [3, 4]])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) OR "users"."id" NOT IN (3, 4)) SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) OR "users"."id" NOT IN (3, 4))
} }
end end
@ -982,14 +982,14 @@ module Arel
describe "#not_in_all" do describe "#not_in_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].not_in_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].not_in_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].not_in_all([[1, 2], [3, 4]]) mgr.where relation[:id].not_in_all([[1, 2], [3, 4]])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) AND "users"."id" NOT IN (3, 4)) SELECT "users"."id" FROM "users" WHERE ("users"."id" NOT IN (1, 2) AND "users"."id" NOT IN (3, 4))
} }
end end
@ -998,14 +998,14 @@ module Arel
describe "#eq_all" do describe "#eq_all" do
it "should create a Grouping node" do it "should create a Grouping node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].eq_all([1, 2]).must_be_kind_of Nodes::Grouping _(relation[:id].eq_all([1, 2])).must_be_kind_of Nodes::Grouping
end end
it "should generate ANDs in sql" do it "should generate ANDs in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.where relation[:id].eq_all([1, 2]) mgr.where relation[:id].eq_all([1, 2])
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2) SELECT "users"."id" FROM "users" WHERE ("users"."id" = 1 AND "users"."id" = 2)
} }
end end
@ -1014,14 +1014,14 @@ module Arel
describe "#asc" do describe "#asc" do
it "should create an Ascending node" do it "should create an Ascending node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].asc.must_be_kind_of Nodes::Ascending _(relation[:id].asc).must_be_kind_of Nodes::Ascending
end end
it "should generate ASC in sql" do it "should generate ASC in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.order relation[:id].asc mgr.order relation[:id].asc
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC SELECT "users"."id" FROM "users" ORDER BY "users"."id" ASC
} }
end end
@ -1030,14 +1030,14 @@ module Arel
describe "#desc" do describe "#desc" do
it "should create a Descending node" do it "should create a Descending node" do
relation = Table.new(:users) relation = Table.new(:users)
relation[:id].desc.must_be_kind_of Nodes::Descending _(relation[:id].desc).must_be_kind_of Nodes::Descending
end end
it "should generate DESC in sql" do it "should generate DESC in sql" do
relation = Table.new(:users) relation = Table.new(:users)
mgr = relation.project relation[:id] mgr = relation.project relation[:id]
mgr.order relation[:id].desc mgr.order relation[:id].desc
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" ORDER BY "users"."id" DESC SELECT "users"."id" FROM "users" ORDER BY "users"."id" DESC
} }
end end
@ -1048,7 +1048,7 @@ module Arel
it "should produce sql" do it "should produce sql" do
table = Table.new :users table = Table.new :users
condition = table["id"].eq 1 condition = table["id"].eq 1
condition.to_sql.must_equal '"users"."id" = 1' _(condition.to_sql).must_equal '"users"."id" = 1'
end end
end end
end end
@ -1059,7 +1059,7 @@ module Arel
condition = table["id"].eq("1") condition = table["id"].eq("1")
assert_not table.able_to_type_cast? assert_not table.able_to_type_cast?
condition.to_sql.must_equal %("foo"."id" = '1') _(condition.to_sql).must_equal %("foo"."id" = '1')
end end
it "type casts when given an explicit caster" do it "type casts when given an explicit caster" do
@ -1075,7 +1075,7 @@ module Arel
condition = table["id"].eq("1").and(table["other_id"].eq("2")) condition = table["id"].eq("1").and(table["other_id"].eq("2"))
assert table.able_to_type_cast? assert table.able_to_type_cast?
condition.to_sql.must_equal %("foo"."id" = 1 AND "foo"."other_id" = '2') _(condition.to_sql).must_equal %("foo"."id" = 1 AND "foo"."other_id" = '2')
end end
it "does not type cast SqlLiteral nodes" do it "does not type cast SqlLiteral nodes" do
@ -1087,7 +1087,7 @@ module Arel
condition = table["id"].eq(Arel.sql("(select 1)")) condition = table["id"].eq(Arel.sql("(select 1)"))
assert table.able_to_type_cast? assert table.able_to_type_cast?
condition.to_sql.must_equal %("foo"."id" = (select 1)) _(condition.to_sql).must_equal %("foo"."id" = (select 1))
end end
end end

20
activerecord/test/cases/arel/attributes/math_test.rb
View File

@ -8,35 +8,35 @@ module Arel
%i[* /].each do |math_operator| %i[* /].each do |math_operator|
it "average should be compatible with #{math_operator}" do it "average should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].average.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].average.public_send(math_operator, 2).to_sql).must_be_like %{
AVG("users"."id") #{math_operator} 2 AVG("users"."id") #{math_operator} 2
} }
end end
it "count should be compatible with #{math_operator}" do it "count should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].count.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].count.public_send(math_operator, 2).to_sql).must_be_like %{
COUNT("users"."id") #{math_operator} 2 COUNT("users"."id") #{math_operator} 2
} }
end end
it "maximum should be compatible with #{math_operator}" do it "maximum should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].maximum.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].maximum.public_send(math_operator, 2).to_sql).must_be_like %{
MAX("users"."id") #{math_operator} 2 MAX("users"."id") #{math_operator} 2
} }
end end
it "minimum should be compatible with #{math_operator}" do it "minimum should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].minimum.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].minimum.public_send(math_operator, 2).to_sql).must_be_like %{
MIN("users"."id") #{math_operator} 2 MIN("users"."id") #{math_operator} 2
} }
end end
it "attribute node should be compatible with #{math_operator}" do it "attribute node should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].public_send(math_operator, 2).to_sql).must_be_like %{
"users"."id" #{math_operator} 2 "users"."id" #{math_operator} 2
} }
end end
@ -45,35 +45,35 @@ module Arel
%i[+ - & | ^ << >>].each do |math_operator| %i[+ - & | ^ << >>].each do |math_operator|
it "average should be compatible with #{math_operator}" do it "average should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].average.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].average.public_send(math_operator, 2).to_sql).must_be_like %{
(AVG("users"."id") #{math_operator} 2) (AVG("users"."id") #{math_operator} 2)
} }
end end
it "count should be compatible with #{math_operator}" do it "count should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].count.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].count.public_send(math_operator, 2).to_sql).must_be_like %{
(COUNT("users"."id") #{math_operator} 2) (COUNT("users"."id") #{math_operator} 2)
} }
end end
it "maximum should be compatible with #{math_operator}" do it "maximum should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].maximum.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].maximum.public_send(math_operator, 2).to_sql).must_be_like %{
(MAX("users"."id") #{math_operator} 2) (MAX("users"."id") #{math_operator} 2)
} }
end end
it "minimum should be compatible with #{math_operator}" do it "minimum should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].minimum.public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].minimum.public_send(math_operator, 2).to_sql).must_be_like %{
(MIN("users"."id") #{math_operator} 2) (MIN("users"."id") #{math_operator} 2)
} }
end end
it "attribute node should be compatible with #{math_operator}" do it "attribute node should be compatible with #{math_operator}" do
table = Arel::Table.new :users table = Arel::Table.new :users
(table[:id].public_send(math_operator, 2)).to_sql.must_be_like %{ _(table[:id].public_send(math_operator, 2).to_sql).must_be_like %{
("users"."id" #{math_operator} 2) ("users"."id" #{math_operator} 2)
} }
end end

8
activerecord/test/cases/arel/delete_manager_test.rb
View File

@ -24,13 +24,13 @@ module Arel
table = Table.new(:users) table = Table.new(:users)
dm = Arel::DeleteManager.new dm = Arel::DeleteManager.new
dm.from table dm.from table
dm.to_sql.must_be_like %{ DELETE FROM "users" } _(dm.to_sql).must_be_like %{ DELETE FROM "users" }
end end
it "chains" do it "chains" do
table = Table.new(:users) table = Table.new(:users)
dm = Arel::DeleteManager.new dm = Arel::DeleteManager.new
dm.from(table).must_equal dm _(dm.from(table)).must_equal dm
end end
end end
@ -40,13 +40,13 @@ module Arel
dm = Arel::DeleteManager.new dm = Arel::DeleteManager.new
dm.from table dm.from table
dm.where table[:id].eq(10) dm.where table[:id].eq(10)
dm.to_sql.must_be_like %{ DELETE FROM "users" WHERE "users"."id" = 10} _(dm.to_sql).must_be_like %{ DELETE FROM "users" WHERE "users"."id" = 10}
end end
it "chains" do it "chains" do
table = Table.new(:users) table = Table.new(:users)
dm = Arel::DeleteManager.new dm = Arel::DeleteManager.new
dm.where(table[:id].eq(10)).must_equal dm _(dm.where(table[:id].eq(10))).must_equal dm
end end
end end
end end

4
activerecord/test/cases/arel/helper.rb
View File

@ -6,9 +6,9 @@ require "arel"
require_relative "support/fake_record" require_relative "support/fake_record"
class Object Minitest::Expectation.class_eval do
def must_be_like(other) def must_be_like(other)
gsub(/\s+/, " ").strip.must_equal other.gsub(/\s+/, " ").strip self.class.new(target.gsub(/\s+/, " ").strip, ctx).must_equal other.gsub(/\s+/, " ").strip
end end
end end

34
activerecord/test/cases/arel/insert_manager_test.rb
View File

@ -23,7 +23,7 @@ module Arel
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.into Table.new(:users) manager.into Table.new(:users)
manager.values = manager.create_values([Arel.sql("*")]) manager.values = manager.create_values([Arel.sql("*")])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO \"users\" VALUES (*) INSERT INTO \"users\" VALUES (*)
} }
end end
@ -42,7 +42,7 @@ module Arel
["3", Arel.sql("DEFAULT")], ["3", Arel.sql("DEFAULT")],
]) ])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO \"users\" (\"id\", \"name\") VALUES ('1', 'david'), ('2', 'kir'), ('3', DEFAULT) INSERT INTO \"users\" (\"id\", \"name\") VALUES ('1', 'david'), ('2', 'kir'), ('3', DEFAULT)
} }
end end
@ -59,7 +59,7 @@ module Arel
[Arel.sql("DEFAULT")], [Arel.sql("DEFAULT")],
]) ])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO \"users\" (\"name\") VALUES (*), (DEFAULT) INSERT INTO \"users\" (\"name\") VALUES (*), (DEFAULT)
} }
end end
@ -77,7 +77,7 @@ module Arel
[Arel.sql("DEFAULT")], [Arel.sql("DEFAULT")],
]) ])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO \"users\" (\"name\") VALUES ('david'), ('kir'), (DEFAULT) INSERT INTO \"users\" (\"name\") VALUES ('david'), ('kir'), (DEFAULT)
} }
end end
@ -87,7 +87,7 @@ module Arel
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.insert [[table[:bool], false]] manager.insert [[table[:bool], false]]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("bool") VALUES ('f') INSERT INTO "users" ("bool") VALUES ('f')
} }
end end
@ -96,7 +96,7 @@ module Arel
table = Table.new(:users) table = Table.new(:users)
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.insert [[table[:id], nil]] manager.insert [[table[:id], nil]]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id") VALUES (NULL) INSERT INTO "users" ("id") VALUES (NULL)
} }
end end
@ -109,7 +109,7 @@ module Arel
attribute = table[:created_at] attribute = table[:created_at]
manager.insert [[attribute, time]] manager.insert [[attribute, time]]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("created_at") VALUES (#{Table.engine.connection.quote time}) INSERT INTO "users" ("created_at") VALUES (#{Table.engine.connection.quote time})
} }
end end
@ -119,7 +119,7 @@ module Arel
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.into table manager.into table
manager.insert [[table[:id], 1], [table[:name], "aaron"]] manager.insert [[table[:id], 1], [table[:name], "aaron"]]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id", "name") VALUES (1, 'aaron') INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
} }
end end
@ -128,7 +128,7 @@ module Arel
table = Table.new(:users) table = Table.new(:users)
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.insert [[table[:id], 1], [table[:name], "aaron"]] manager.insert [[table[:id], 1], [table[:name], "aaron"]]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id", "name") VALUES (1, 'aaron') INSERT INTO "users" ("id", "name") VALUES (1, 'aaron')
} }
end end
@ -138,7 +138,7 @@ module Arel
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.insert [[table[:id], 1]] manager.insert [[table[:id], 1]]
manager.insert [] manager.insert []
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id") VALUES (1) INSERT INTO "users" ("id") VALUES (1)
} }
end end
@ -154,14 +154,14 @@ module Arel
describe "into" do describe "into" do
it "takes a Table and chains" do it "takes a Table and chains" do
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.into(Table.new(:users)).must_equal manager _(manager.into(Table.new(:users))).must_equal manager
end end
it "converts to sql" do it "converts to sql" do
table = Table.new :users table = Table.new :users
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.into table manager.into table
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" INSERT INTO "users"
} }
end end
@ -173,7 +173,7 @@ module Arel
manager = Arel::InsertManager.new manager = Arel::InsertManager.new
manager.into table manager.into table
manager.columns << table[:id] manager.columns << table[:id]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id") INSERT INTO "users" ("id")
} }
end end
@ -186,7 +186,7 @@ module Arel
manager.into table manager.into table
manager.values = Nodes::ValuesList.new([[1], [2]]) manager.values = Nodes::ValuesList.new([[1], [2]])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" VALUES (1), (2) INSERT INTO "users" VALUES (1), (2)
} }
end end
@ -197,7 +197,7 @@ module Arel
manager.into table manager.into table
manager.values = Arel.sql("DEFAULT VALUES") manager.values = Arel.sql("DEFAULT VALUES")
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" DEFAULT VALUES INSERT INTO "users" DEFAULT VALUES
} }
end end
@ -212,7 +212,7 @@ module Arel
manager.values = Nodes::ValuesList.new([[1, "aaron"], [2, "david"]]) manager.values = Nodes::ValuesList.new([[1, "aaron"], [2, "david"]])
manager.columns << table[:id] manager.columns << table[:id]
manager.columns << table[:name] manager.columns << table[:name]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id", "name") VALUES (1, 'aaron'), (2, 'david') INSERT INTO "users" ("id", "name") VALUES (1, 'aaron'), (2, 'david')
} }
end end
@ -232,7 +232,7 @@ module Arel
manager.select select manager.select select
manager.columns << table[:id] manager.columns << table[:id]
manager.columns << table[:name] manager.columns << table[:name]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
INSERT INTO "users" ("id", "name") (SELECT 1, "aaron") INSERT INTO "users" ("id", "name") (SELECT 1, "aaron")
} }
end end

8
activerecord/test/cases/arel/nodes/bind_param_test.rb
View File

@ -6,16 +6,16 @@ module Arel
module Nodes module Nodes
describe "BindParam" do describe "BindParam" do
it "is equal to other bind params with the same value" do it "is equal to other bind params with the same value" do
BindParam.new(1).must_equal(BindParam.new(1)) _(BindParam.new(1)).must_equal(BindParam.new(1))
BindParam.new("foo").must_equal(BindParam.new("foo")) _(BindParam.new("foo")).must_equal(BindParam.new("foo"))
end end
it "is not equal to other nodes" do it "is not equal to other nodes" do
BindParam.new(nil).wont_equal(Node.new) _(BindParam.new(nil)).wont_equal(Node.new)
end end
it "is not equal to bind params with different values" do it "is not equal to bind params with different values" do
BindParam.new(1).wont_equal(BindParam.new(2)) _(BindParam.new(1)).wont_equal(BindParam.new(2))
end end
end end
end end

4
activerecord/test/cases/arel/nodes/count_test.rb
View File

@ -6,7 +6,7 @@ class Arel::Nodes::CountTest < Arel::Spec
describe "as" do describe "as" do
it "should alias the count" do it "should alias the count" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].count.as("foo").to_sql.must_be_like %{ _(table[:id].count.as("foo").to_sql).must_be_like %{
COUNT("users"."id") AS foo COUNT("users"."id") AS foo
} }
end end
@ -15,7 +15,7 @@ class Arel::Nodes::CountTest < Arel::Spec
describe "eq" do describe "eq" do
it "should compare the count" do it "should compare the count" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].count.eq(2).to_sql.must_be_like %{ _(table[:id].count.eq(2).to_sql).must_be_like %{
COUNT("users"."id") = 2 COUNT("users"."id") = 2
} }
end end

4
activerecord/test/cases/arel/nodes/delete_statement_test.rb
View File

@ -9,8 +9,8 @@ describe Arel::Nodes::DeleteStatement do
statement.wheres = %w[a b c] statement.wheres = %w[a b c]
dolly = statement.clone dolly = statement.clone
dolly.wheres.must_equal statement.wheres _(dolly.wheres).must_equal statement.wheres
dolly.wheres.wont_be_same_as statement.wheres _(dolly.wheres).wont_be_same_as statement.wheres
end end
end end

16
activerecord/test/cases/arel/nodes/equality_test.rb
View File

@ -11,7 +11,7 @@ module Arel
it "returns :==" do it "returns :==" do
attr = Table.new(:users)[:id] attr = Table.new(:users)[:id]
left = attr.eq(10) left = attr.eq(10)
left.operator.must_equal :== _(left.operator).must_equal :==
end end
end end
@ -19,7 +19,7 @@ module Arel
it "should equal left" do it "should equal left" do
attr = Table.new(:users)[:id] attr = Table.new(:users)[:id]
left = attr.eq(10) left = attr.eq(10)
left.left.must_equal left.operand1 _(left.left).must_equal left.operand1
end end
end end
@ -27,7 +27,7 @@ module Arel
it "should equal right" do it "should equal right" do
attr = Table.new(:users)[:id] attr = Table.new(:users)[:id]
left = attr.eq(10) left = attr.eq(10)
left.right.must_equal left.operand2 _(left.right).must_equal left.operand2
end end
end end
@ -45,7 +45,7 @@ module Arel
attr = Table.new(:users)[:id] attr = Table.new(:users)[:id]
test = attr.eq(10) test = attr.eq(10)
test.to_sql engine test.to_sql engine
engine.connection.quote_count.must_equal 3 _(engine.connection.quote_count).must_equal 3
end end
end end
end end
@ -56,8 +56,8 @@ module Arel
left = attr.eq(10) left = attr.eq(10)
right = attr.eq(11) right = attr.eq(11)
node = left.or right node = left.or right
node.expr.left.must_equal left _(node.expr.left).must_equal left
node.expr.right.must_equal right _(node.expr.right).must_equal right
end end
end end
@ -67,8 +67,8 @@ module Arel
left = attr.eq(10) left = attr.eq(10)
right = attr.eq(11) right = attr.eq(11)
node = left.and right node = left.and right
node.left.must_equal left _(node.left).must_equal left
node.right.must_equal right _(node.right).must_equal right
end end
end end

4
activerecord/test/cases/arel/nodes/extract_test.rb
View File

@ -5,7 +5,7 @@ require_relative "../helper"
class Arel::Nodes::ExtractTest < Arel::Spec class Arel::Nodes::ExtractTest < Arel::Spec
it "should extract field" do it "should extract field" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:timestamp].extract("date").to_sql.must_be_like %{ _(table[:timestamp].extract("date").to_sql).must_be_like %{
EXTRACT(DATE FROM "users"."timestamp") EXTRACT(DATE FROM "users"."timestamp")
} }
end end
@ -13,7 +13,7 @@ class Arel::Nodes::ExtractTest < Arel::Spec
describe "as" do describe "as" do
it "should alias the extract" do it "should alias the extract" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:timestamp].extract("date").as("foo").to_sql.must_be_like %{ _(table[:timestamp].extract("date").as("foo").to_sql).must_be_like %{
EXTRACT(DATE FROM "users"."timestamp") AS foo EXTRACT(DATE FROM "users"."timestamp") AS foo
} }
end end

2
activerecord/test/cases/arel/nodes/grouping_test.rb
View File

@ -7,7 +7,7 @@ module Arel
class GroupingTest < Arel::Spec class GroupingTest < Arel::Spec
it "should create Equality nodes" do it "should create Equality nodes" do
grouping = Grouping.new(Nodes.build_quoted("foo")) grouping = Grouping.new(Nodes.build_quoted("foo"))
grouping.eq("foo").to_sql.must_be_like "('foo') = 'foo'" _(grouping.eq("foo").to_sql).must_be_like "('foo') = 'foo'"
end end
describe "equality" do describe "equality" do

8
activerecord/test/cases/arel/nodes/insert_statement_test.rb
View File

@ -10,11 +10,11 @@ describe Arel::Nodes::InsertStatement do
statement.values = %w[x y z] statement.values = %w[x y z]
dolly = statement.clone dolly = statement.clone
dolly.columns.must_equal statement.columns _(dolly.columns).must_equal statement.columns
dolly.values.must_equal statement.values _(dolly.values).must_equal statement.values
dolly.columns.wont_be_same_as statement.columns _(dolly.columns).wont_be_same_as statement.columns
dolly.values.wont_be_same_as statement.values _(dolly.values).wont_be_same_as statement.values
end end
end end

4
activerecord/test/cases/arel/nodes/not_test.rb
View File

@ -10,8 +10,8 @@ module Arel
attr = Table.new(:users)[:id] attr = Table.new(:users)[:id]
expr = attr.eq(10) expr = attr.eq(10)
node = expr.not node = expr.not
node.must_be_kind_of Not _(node).must_be_kind_of Not
node.expr.must_equal expr _(node.expr).must_equal expr
end end
end end

8
activerecord/test/cases/arel/nodes/or_test.rb
View File

@ -11,12 +11,12 @@ module Arel
left = attr.eq(10) left = attr.eq(10)
right = attr.eq(11) right = attr.eq(11)
node = left.or right node = left.or right
node.expr.left.must_equal left _(node.expr.left).must_equal left
node.expr.right.must_equal right _(node.expr.right).must_equal right
oror = node.or(right) oror = node.or(right)
oror.expr.left.must_equal node _(oror.expr.left).must_equal node
oror.expr.right.must_equal right _(oror.expr.right).must_equal right
end end
end end

10
activerecord/test/cases/arel/nodes/over_test.rb
View File

@ -6,7 +6,7 @@ class Arel::Nodes::OverTest < Arel::Spec
describe "as" do describe "as" do
it "should alias the expression" do it "should alias the expression" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].count.over.as("foo").to_sql.must_be_like %{ _(table[:id].count.over.as("foo").to_sql).must_be_like %{
COUNT("users"."id") OVER () AS foo COUNT("users"."id") OVER () AS foo
} }
end end
@ -15,7 +15,7 @@ class Arel::Nodes::OverTest < Arel::Spec
describe "with literal" do describe "with literal" do
it "should reference the window definition by name" do it "should reference the window definition by name" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].count.over("foo").to_sql.must_be_like %{ _(table[:id].count.over("foo").to_sql).must_be_like %{
COUNT("users"."id") OVER "foo" COUNT("users"."id") OVER "foo"
} }
end end
@ -24,7 +24,7 @@ class Arel::Nodes::OverTest < Arel::Spec
describe "with SQL literal" do describe "with SQL literal" do
it "should reference the window definition by name" do it "should reference the window definition by name" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].count.over(Arel.sql("foo")).to_sql.must_be_like %{ _(table[:id].count.over(Arel.sql("foo")).to_sql).must_be_like %{
COUNT("users"."id") OVER foo COUNT("users"."id") OVER foo
} }
end end
@ -33,7 +33,7 @@ class Arel::Nodes::OverTest < Arel::Spec
describe "with no expression" do describe "with no expression" do
it "should use empty definition" do it "should use empty definition" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].count.over.to_sql.must_be_like %{ _(table[:id].count.over.to_sql).must_be_like %{
COUNT("users"."id") OVER () COUNT("users"."id") OVER ()
} }
end end
@ -43,7 +43,7 @@ class Arel::Nodes::OverTest < Arel::Spec
it "should use definition in sub-expression" do it "should use definition in sub-expression" do
table = Arel::Table.new :users table = Arel::Table.new :users
window = Arel::Nodes::Window.new.order(table["foo"]) window = Arel::Nodes::Window.new.order(table["foo"])
table[:id].count.over(window).to_sql.must_be_like %{ _(table[:id].count.over(window).to_sql).must_be_like %{
COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\") COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\")
} }
end end

4
activerecord/test/cases/arel/nodes/select_statement_test.rb
View File

@ -8,8 +8,8 @@ describe Arel::Nodes::SelectStatement do
statement = Arel::Nodes::SelectStatement.new %w[a b c] statement = Arel::Nodes::SelectStatement.new %w[a b c]
dolly = statement.clone dolly = statement.clone
dolly.cores.must_equal statement.cores _(dolly.cores).must_equal statement.cores
dolly.cores.wont_be_same_as statement.cores _(dolly.cores).wont_be_same_as statement.cores
end end
end end

12
activerecord/test/cases/arel/nodes/sql_literal_test.rb
View File

@ -17,26 +17,26 @@ module Arel
describe "sql" do describe "sql" do
it "makes a sql literal node" do it "makes a sql literal node" do
sql = Arel.sql "foo" sql = Arel.sql "foo"
sql.must_be_kind_of Arel::Nodes::SqlLiteral _(sql).must_be_kind_of Arel::Nodes::SqlLiteral
end end
end end
describe "count" do describe "count" do
it "makes a count node" do it "makes a count node" do
node = SqlLiteral.new("*").count node = SqlLiteral.new("*").count
compile(node).must_be_like %{ COUNT(*) } _(compile(node)).must_be_like %{ COUNT(*) }
end end
it "makes a distinct node" do it "makes a distinct node" do
node = SqlLiteral.new("*").count true node = SqlLiteral.new("*").count true
compile(node).must_be_like %{ COUNT(DISTINCT *) } _(compile(node)).must_be_like %{ COUNT(DISTINCT *) }
end end
end end
describe "equality" do describe "equality" do
it "makes an equality node" do it "makes an equality node" do
node = SqlLiteral.new("foo").eq(1) node = SqlLiteral.new("foo").eq(1)
compile(node).must_be_like %{ foo = 1 } _(compile(node)).must_be_like %{ foo = 1 }
end end
it "is equal with equal contents" do it "is equal with equal contents" do
@ -53,14 +53,14 @@ module Arel
describe 'grouped "or" equality' do describe 'grouped "or" equality' do
it "makes a grouping node with an or node" do it "makes a grouping node with an or node" do
node = SqlLiteral.new("foo").eq_any([1, 2]) node = SqlLiteral.new("foo").eq_any([1, 2])
compile(node).must_be_like %{ (foo = 1 OR foo = 2) } _(compile(node)).must_be_like %{ (foo = 1 OR foo = 2) }
end end
end end
describe 'grouped "and" equality' do describe 'grouped "and" equality' do
it "makes a grouping node with an and node" do it "makes a grouping node with an and node" do
node = SqlLiteral.new("foo").eq_all([1, 2]) node = SqlLiteral.new("foo").eq_all([1, 2])
compile(node).must_be_like %{ (foo = 1 AND foo = 2) } _(compile(node)).must_be_like %{ (foo = 1 AND foo = 2) }
end end
end end

4
activerecord/test/cases/arel/nodes/sum_test.rb
View File

@ -6,7 +6,7 @@ class Arel::Nodes::SumTest < Arel::Spec
describe "as" do describe "as" do
it "should alias the sum" do it "should alias the sum" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].sum.as("foo").to_sql.must_be_like %{ _(table[:id].sum.as("foo").to_sql).must_be_like %{
SUM("users"."id") AS foo SUM("users"."id") AS foo
} }
end end
@ -27,7 +27,7 @@ class Arel::Nodes::SumTest < Arel::Spec
describe "order" do describe "order" do
it "should order the sum" do it "should order the sum" do
table = Arel::Table.new :users table = Arel::Table.new :users
table[:id].sum.desc.to_sql.must_be_like %{ _(table[:id].sum.desc.to_sql).must_be_like %{
SUM("users"."id") DESC SUM("users"."id") DESC
} }
end end

8
activerecord/test/cases/arel/nodes/update_statement_test.rb
View File

@ -10,11 +10,11 @@ describe Arel::Nodes::UpdateStatement do
statement.values = %w[x y z] statement.values = %w[x y z]
dolly = statement.clone dolly = statement.clone
dolly.wheres.must_equal statement.wheres _(dolly.wheres).must_equal statement.wheres
dolly.wheres.wont_be_same_as statement.wheres _(dolly.wheres).wont_be_same_as statement.wheres
dolly.values.must_equal statement.values _(dolly.values).must_equal statement.values
dolly.values.wont_be_same_as statement.values _(dolly.values).wont_be_same_as statement.values
end end
end end

210
activerecord/test/cases/arel/select_manager_test.rb
View File

@ -17,7 +17,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project :id manager.project :id
manager.from table manager.from table
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT id FROM "users" SELECT id FROM "users"
} }
end end
@ -30,7 +30,7 @@ module Arel
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
manager.from table manager.from table
manager.order :foo manager.order :foo
manager.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo } _(manager.to_sql).must_be_like %{ SELECT * FROM "users" ORDER BY foo }
end end
end end
@ -40,7 +40,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.group :foo manager.group :foo
manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo } _(manager.to_sql).must_be_like %{ SELECT FROM "users" GROUP BY foo }
end end
end end
@ -68,7 +68,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project Arel.sql("name") manager.project Arel.sql("name")
manager.from as manager.from as
manager.to_sql.must_be_like "SELECT name FROM (SELECT * FROM zomg) foo" _(manager.to_sql).must_be_like "SELECT name FROM (SELECT * FROM zomg) foo"
end end
end end
@ -80,7 +80,7 @@ module Arel
manager.from table manager.from table
manager.from "users" manager.from "users"
manager.project table["id"] manager.project table["id"]
manager.to_sql.must_be_like 'SELECT "users"."id" FROM users' _(manager.to_sql).must_be_like 'SELECT "users"."id" FROM users'
end end
it "should support any ast" do it "should support any ast" do
@ -95,7 +95,7 @@ module Arel
as = manager2.as Arel.sql("omg") as = manager2.as Arel.sql("omg")
manager1.from(as) manager1.from(as)
manager1.to_sql.must_be_like %{ _(manager1.to_sql).must_be_like %{
SELECT lol FROM (SELECT * FROM "users") omg SELECT lol FROM (SELECT * FROM "users") omg
} }
end end
@ -106,7 +106,7 @@ module Arel
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.having Arel.sql("foo") mgr.having Arel.sql("foo")
mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" HAVING foo }
end end
it "can have multiple items specified separately" do it "can have multiple items specified separately" do
@ -114,14 +114,14 @@ module Arel
mgr = table.from mgr = table.from
mgr.having Arel.sql("foo") mgr.having Arel.sql("foo")
mgr.having Arel.sql("bar") mgr.having Arel.sql("bar")
mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
end end
it "can receive any node" do it "can receive any node" do
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.having Arel::Nodes::And.new([Arel.sql("foo"), Arel.sql("bar")]) mgr.having Arel::Nodes::And.new([Arel.sql("foo"), Arel.sql("bar")])
mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
end end
end end
@ -131,7 +131,7 @@ module Arel
right = table.alias right = table.alias
mgr = table.from mgr = table.from
mgr.join(right).on("omg") mgr.join(right).on("omg")
mgr.to_sql.must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg }
end end
it "converts to sqlliterals with multiple items" do it "converts to sqlliterals with multiple items" do
@ -139,7 +139,7 @@ module Arel
right = table.alias right = table.alias
mgr = table.from mgr = table.from
mgr.join(right).on("omg", "123") mgr.join(right).on("omg", "123")
mgr.to_sql.must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg AND 123 } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg AND 123 }
end end
end end
end end
@ -150,7 +150,7 @@ module Arel
mgr = table.from mgr = table.from
m2 = mgr.clone m2 = mgr.clone
m2.project "foo" m2.project "foo"
mgr.to_sql.wont_equal m2.to_sql _(mgr.to_sql).wont_equal m2.to_sql
end end
it "makes updates to the correct copy" do it "makes updates to the correct copy" do
@ -159,8 +159,8 @@ module Arel
m2 = mgr.clone m2 = mgr.clone
m3 = m2.clone m3 = m2.clone
m2.project "foo" m2.project "foo"
mgr.to_sql.wont_equal m2.to_sql _(mgr.to_sql).wont_equal m2.to_sql
m3.to_sql.must_equal mgr.to_sql _(m3.to_sql).must_equal mgr.to_sql
end end
end end
@ -169,7 +169,7 @@ module Arel
table = Table.new :users, as: "foo" table = Table.new :users, as: "foo"
mgr = table.from mgr = table.from
mgr.skip 10 mgr.skip 10
mgr.to_sql.must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
end end
end end
@ -178,13 +178,13 @@ module Arel
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.skip 10 mgr.skip 10
mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
end end
it "should chain" do it "should chain" do
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.skip(10).to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 } _(mgr.skip(10).to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
end end
end end
@ -193,17 +193,17 @@ module Arel
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.offset = 10 mgr.offset = 10
mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
end end
it "should remove an offset" do it "should remove an offset" do
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.offset = 10 mgr.offset = 10
mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" OFFSET 10 }
mgr.offset = nil mgr.offset = nil
mgr.to_sql.must_be_like %{ SELECT FROM "users" } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" }
end end
it "should return the offset" do it "should return the offset" do
@ -221,7 +221,7 @@ module Arel
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
m2 = Arel::SelectManager.new m2 = Arel::SelectManager.new
m2.project manager.exists m2.project manager.exists
m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) } _(m2.to_sql).must_be_like %{ SELECT EXISTS (#{manager.to_sql}) }
end end
it "can be aliased" do it "can be aliased" do
@ -230,7 +230,7 @@ module Arel
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
m2 = Arel::SelectManager.new m2 = Arel::SelectManager.new
m2.project manager.exists.as("foo") m2.project manager.exists.as("foo")
m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) AS foo } _(m2.to_sql).must_be_like %{ SELECT EXISTS (#{manager.to_sql}) AS foo }
end end
end end
@ -252,7 +252,7 @@ module Arel
node = @m1.union @m2 node = @m1.union @m2
# maybe FIXME: decide when wrapper parens are needed # maybe FIXME: decide when wrapper parens are needed
node.to_sql.must_be_like %{ _(node.to_sql).must_be_like %{
( SELECT * FROM "users" WHERE "users"."age" < 18 UNION SELECT * FROM "users" WHERE "users"."age" > 99 ) ( SELECT * FROM "users" WHERE "users"."age" < 18 UNION SELECT * FROM "users" WHERE "users"."age" > 99 )
} }
end end
@ -260,7 +260,7 @@ module Arel
it "should union all" do it "should union all" do
node = @m1.union :all, @m2 node = @m1.union :all, @m2
node.to_sql.must_be_like %{ _(node.to_sql).must_be_like %{
( SELECT * FROM "users" WHERE "users"."age" < 18 UNION ALL SELECT * FROM "users" WHERE "users"."age" > 99 ) ( SELECT * FROM "users" WHERE "users"."age" < 18 UNION ALL SELECT * FROM "users" WHERE "users"."age" > 99 )
} }
end end
@ -284,7 +284,7 @@ module Arel
node = @m1.intersect @m2 node = @m1.intersect @m2
# maybe FIXME: decide when wrapper parens are needed # maybe FIXME: decide when wrapper parens are needed
node.to_sql.must_be_like %{ _(node.to_sql).must_be_like %{
( SELECT * FROM "users" WHERE "users"."age" > 18 INTERSECT SELECT * FROM "users" WHERE "users"."age" < 99 ) ( SELECT * FROM "users" WHERE "users"."age" > 18 INTERSECT SELECT * FROM "users" WHERE "users"."age" < 99 )
} }
end end
@ -308,7 +308,7 @@ module Arel
node = @m1.except @m2 node = @m1.except @m2
# maybe FIXME: decide when wrapper parens are needed # maybe FIXME: decide when wrapper parens are needed
node.to_sql.must_be_like %{ _(node.to_sql).must_be_like %{
( SELECT * FROM "users" WHERE "users"."age" BETWEEN 18 AND 60 EXCEPT SELECT * FROM "users" WHERE "users"."age" BETWEEN 40 AND 99 ) ( SELECT * FROM "users" WHERE "users"."age" BETWEEN 18 AND 60 EXCEPT SELECT * FROM "users" WHERE "users"."age" BETWEEN 40 AND 99 )
} }
end end
@ -325,7 +325,7 @@ module Arel
select_manager = comments.project(Arel.star).with(users_as) select_manager = comments.project(Arel.star).with(users_as)
.where(comments[:author_id].in(users_top.project(users_top[:id]))) .where(comments[:author_id].in(users_top.project(users_top[:id])))
select_manager.to_sql.must_be_like %{ _(select_manager.to_sql).must_be_like %{
WITH "users_top" AS (SELECT "users"."id" FROM "users" WHERE "users"."karma" > 100) SELECT * FROM "comments" WHERE "comments"."author_id" IN (SELECT "users_top"."id" FROM "users_top") WITH "users_top" AS (SELECT "users"."id" FROM "users" WHERE "users"."karma" > 100) SELECT * FROM "comments" WHERE "comments"."author_id" IN (SELECT "users_top"."id" FROM "users_top")
} }
end end
@ -352,7 +352,7 @@ module Arel
manager.with(:recursive, as_statement).from(replies).project(Arel.star) manager.with(:recursive, as_statement).from(replies).project(Arel.star)
sql = manager.to_sql sql = manager.to_sql
sql.must_be_like %{ _(sql).must_be_like %{
WITH RECURSIVE "replies" AS ( WITH RECURSIVE "replies" AS (
SELECT "comments"."id", "comments"."parent_id" FROM "comments" WHERE "comments"."id" = 42 SELECT "comments"."id", "comments"."parent_id" FROM "comments" WHERE "comments"."id" = 42
UNION UNION
@ -375,7 +375,7 @@ module Arel
it "should return limit" do it "should return limit" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.take 10 manager.take 10
manager.taken.must_equal 10 _(manager.taken).must_equal 10
end end
end end
@ -384,7 +384,7 @@ module Arel
it "adds a lock node" do it "adds a lock node" do
table = Table.new :users table = Table.new :users
mgr = table.from mgr = table.from
mgr.lock.to_sql.must_be_like %{ SELECT FROM "users" FOR UPDATE } _(mgr.lock.to_sql).must_be_like %{ SELECT FROM "users" FOR UPDATE }
end end
end end
@ -394,7 +394,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
order = table[:id] order = table[:id]
manager.order table[:id] manager.order table[:id]
manager.orders.must_equal [order] _(manager.orders).must_equal [order]
end end
end end
@ -405,7 +405,7 @@ module Arel
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
manager.from table manager.from table
manager.order table[:id] manager.order table[:id]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT * FROM "users" ORDER BY "users"."id" SELECT * FROM "users" ORDER BY "users"."id"
} }
end end
@ -417,7 +417,7 @@ module Arel
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
manager.from table manager.from table
manager.order table[:id], table[:name] manager.order table[:id], table[:name]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT * FROM "users" ORDER BY "users"."id", "users"."name" SELECT * FROM "users" ORDER BY "users"."id", "users"."name"
} }
end end
@ -425,7 +425,7 @@ module Arel
it "chains" do it "chains" do
table = Table.new :users table = Table.new :users
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.order(table[:id]).must_equal manager _(manager.order(table[:id])).must_equal manager
end end
it "has order attributes" do it "has order attributes" do
@ -434,7 +434,7 @@ module Arel
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
manager.from table manager.from table
manager.order table[:id].desc manager.order table[:id].desc
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT * FROM "users" ORDER BY "users"."id" DESC SELECT * FROM "users" ORDER BY "users"."id" DESC
} }
end end
@ -449,7 +449,7 @@ module Arel
manager.from left manager.from left
manager.join(right).on(predicate, predicate) manager.join(right).on(predicate, predicate)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
INNER JOIN "users" "users_2" INNER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" AND ON "users"."id" = "users_2"."id" AND
@ -469,7 +469,7 @@ module Arel
predicate, predicate,
left[:name].eq(right[:name]) left[:name].eq(right[:name])
) )
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
INNER JOIN "users" "users_2" INNER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" AND ON "users"."id" = "users_2"."id" AND
@ -539,7 +539,7 @@ module Arel
manager.from left manager.from left
manager.join(right).on(predicate) manager.join(right).on(predicate)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
INNER JOIN "users" "users_2" INNER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -554,7 +554,7 @@ module Arel
manager.from left manager.from left
manager.join(right, Nodes::OuterJoin).on(predicate) manager.join(right, Nodes::OuterJoin).on(predicate)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
LEFT OUTER JOIN "users" "users_2" LEFT OUTER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -569,7 +569,7 @@ module Arel
manager.from left manager.from left
manager.join(right, Nodes::FullOuterJoin).on(predicate) manager.join(right, Nodes::FullOuterJoin).on(predicate)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
FULL OUTER JOIN "users" "users_2" FULL OUTER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -584,7 +584,7 @@ module Arel
manager.from left manager.from left
manager.join(right, Nodes::RightOuterJoin).on(predicate) manager.join(right, Nodes::RightOuterJoin).on(predicate)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
RIGHT OUTER JOIN "users" "users_2" RIGHT OUTER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -593,7 +593,7 @@ module Arel
it "noops on nil" do it "noops on nil" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.join(nil).must_equal manager _(manager.join(nil)).must_equal manager
end end
it "raises EmptyJoinError on empty" do it "raises EmptyJoinError on empty" do
@ -616,7 +616,7 @@ module Arel
manager.from left manager.from left
manager.outer_join(right).on(predicate) manager.outer_join(right).on(predicate)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
LEFT OUTER JOIN "users" "users_2" LEFT OUTER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -625,7 +625,7 @@ module Arel
it "noops on nil" do it "noops on nil" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.outer_join(nil).must_equal manager _(manager.outer_join(nil)).must_equal manager
end end
end end
@ -660,7 +660,7 @@ module Arel
).as("counts") ).as("counts")
joins = users.join(counts).on(counts[:user_id].eq(10)) joins = users.join(counts).on(counts[:user_id].eq(10))
joins.to_sql.must_be_like %{ _(joins.to_sql).must_be_like %{
SELECT FROM "users" INNER JOIN (SELECT "comments"."user_id" AS user_id, COUNT("comments"."user_id") AS count FROM "comments" GROUP BY "comments"."user_id") counts ON counts."user_id" = 10 SELECT FROM "users" INNER JOIN (SELECT "comments"."user_id" AS user_id, COUNT("comments"."user_id") AS count FROM "comments" GROUP BY "comments"."user_id") counts ON counts."user_id" = 10
} }
end end
@ -672,9 +672,9 @@ module Arel
mgr = left.join(right) mgr = left.join(right)
mgr.project Nodes::SqlLiteral.new("*") mgr.project Nodes::SqlLiteral.new("*")
mgr.on(predicate).must_equal mgr _(mgr.on(predicate)).must_equal mgr
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT * FROM "users" SELECT * FROM "users"
INNER JOIN "users" "users_2" INNER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -694,7 +694,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.group table[:id] manager.group table[:id]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" GROUP BY "users"."id" SELECT FROM "users" GROUP BY "users"."id"
} }
end end
@ -702,7 +702,7 @@ module Arel
it "chains" do it "chains" do
table = Table.new :users table = Table.new :users
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.group(table[:id]).must_equal manager _(manager.group(table[:id])).must_equal manager
end end
it "takes multiple args" do it "takes multiple args" do
@ -710,7 +710,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.group table[:id], table[:name] manager.group table[:id], table[:name]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" GROUP BY "users"."id", "users"."name" SELECT FROM "users" GROUP BY "users"."id", "users"."name"
} }
end end
@ -721,7 +721,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.group "foo" manager.group "foo"
manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo } _(manager.to_sql).must_be_like %{ SELECT FROM "users" GROUP BY foo }
end end
end end
@ -731,7 +731,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window") manager.window("a_window")
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS () SELECT FROM "users" WINDOW "a_window" AS ()
} }
end end
@ -741,7 +741,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").order(table["foo"].asc) manager.window("a_window").order(table["foo"].asc)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC) SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC)
} }
end end
@ -751,7 +751,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").order(table["foo"].asc, table["bar"].desc) manager.window("a_window").order(table["foo"].asc, table["bar"].desc)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC, "users"."bar" DESC) SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC, "users"."bar" DESC)
} }
end end
@ -761,7 +761,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").partition(table["bar"]) manager.window("a_window").partition(table["bar"])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar") SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar")
} }
end end
@ -771,7 +771,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").partition(table["foo"]).order(table["foo"].asc) manager.window("a_window").partition(table["foo"]).order(table["foo"].asc)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."foo" SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."foo"
ORDER BY "users"."foo" ASC) ORDER BY "users"."foo" ASC)
} }
@ -782,7 +782,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").partition(table["bar"], table["baz"]) manager.window("a_window").partition(table["bar"], table["baz"])
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar", "users"."baz") SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar", "users"."baz")
} }
end end
@ -792,7 +792,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").rows(Arel::Nodes::Preceding.new) manager.window("a_window").rows(Arel::Nodes::Preceding.new)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED PRECEDING) SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED PRECEDING)
} }
end end
@ -802,7 +802,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").rows(Arel::Nodes::Preceding.new(5)) manager.window("a_window").rows(Arel::Nodes::Preceding.new(5))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 PRECEDING) SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 PRECEDING)
} }
end end
@ -812,7 +812,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").rows(Arel::Nodes::Following.new) manager.window("a_window").rows(Arel::Nodes::Following.new)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED FOLLOWING) SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED FOLLOWING)
} }
end end
@ -822,7 +822,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").rows(Arel::Nodes::Following.new(5)) manager.window("a_window").rows(Arel::Nodes::Following.new(5))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 FOLLOWING) SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 FOLLOWING)
} }
end end
@ -832,7 +832,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").rows(Arel::Nodes::CurrentRow.new) manager.window("a_window").rows(Arel::Nodes::CurrentRow.new)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ROWS CURRENT ROW) SELECT FROM "users" WINDOW "a_window" AS (ROWS CURRENT ROW)
} }
end end
@ -849,7 +849,7 @@ module Arel
Arel::Nodes::Preceding.new, Arel::Nodes::Preceding.new,
Arel::Nodes::CurrentRow.new Arel::Nodes::CurrentRow.new
]))) ])))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) SELECT FROM "users" WINDOW "a_window" AS (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
} }
end end
@ -859,7 +859,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").range(Arel::Nodes::Preceding.new) manager.window("a_window").range(Arel::Nodes::Preceding.new)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED PRECEDING) SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED PRECEDING)
} }
end end
@ -869,7 +869,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").range(Arel::Nodes::Preceding.new(5)) manager.window("a_window").range(Arel::Nodes::Preceding.new(5))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 PRECEDING) SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 PRECEDING)
} }
end end
@ -879,7 +879,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").range(Arel::Nodes::Following.new) manager.window("a_window").range(Arel::Nodes::Following.new)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED FOLLOWING) SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED FOLLOWING)
} }
end end
@ -889,7 +889,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").range(Arel::Nodes::Following.new(5)) manager.window("a_window").range(Arel::Nodes::Following.new(5))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 FOLLOWING) SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 FOLLOWING)
} }
end end
@ -899,7 +899,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.window("a_window").range(Arel::Nodes::CurrentRow.new) manager.window("a_window").range(Arel::Nodes::CurrentRow.new)
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (RANGE CURRENT ROW) SELECT FROM "users" WINDOW "a_window" AS (RANGE CURRENT ROW)
} }
end end
@ -916,7 +916,7 @@ module Arel
Arel::Nodes::Preceding.new, Arel::Nodes::Preceding.new,
Arel::Nodes::CurrentRow.new Arel::Nodes::CurrentRow.new
]))) ])))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" WINDOW "a_window" AS (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) SELECT FROM "users" WINDOW "a_window" AS (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
} }
end end
@ -929,7 +929,7 @@ module Arel
manager.from table manager.from table
stmt = manager.compile_delete stmt = manager.compile_delete
stmt.to_sql.must_be_like %{ DELETE FROM "users" } _(stmt.to_sql).must_be_like %{ DELETE FROM "users" }
end end
it "copies where" do it "copies where" do
@ -939,7 +939,7 @@ module Arel
manager.where table[:id].eq 10 manager.where table[:id].eq 10
stmt = manager.compile_delete stmt = manager.compile_delete
stmt.to_sql.must_be_like %{ _(stmt.to_sql).must_be_like %{
DELETE FROM "users" WHERE "users"."id" = 10 DELETE FROM "users" WHERE "users"."id" = 10
} }
end end
@ -951,7 +951,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.where table[:id].eq 10 manager.where table[:id].eq 10
manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 } _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 }
end end
it "joins wheres with AND" do it "joins wheres with AND" do
@ -960,7 +960,7 @@ module Arel
manager.from table manager.from table
manager.where table[:id].eq 10 manager.where table[:id].eq 10
manager.where table[:id].eq 11 manager.where table[:id].eq 11
manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 AND "users"."id" = 11} _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 AND "users"."id" = 11}
end end
it "handles database specific statements" do it "handles database specific statements" do
@ -971,7 +971,7 @@ module Arel
manager.from table manager.from table
manager.where table[:id].eq 10 manager.where table[:id].eq 10
manager.where table[:name].matches "foo%" manager.where table[:name].matches "foo%"
manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 AND "users"."name" ILIKE 'foo%' } _(manager.where_sql).must_be_like %{ WHERE "users"."id" = 10 AND "users"."name" ILIKE 'foo%' }
Table.engine.connection.visitor = old_visitor Table.engine.connection.visitor = old_visitor
end end
@ -979,7 +979,7 @@ module Arel
table = Table.new :users table = Table.new :users
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from table manager.from table
manager.where_sql.must_be_nil _(manager.where_sql).must_be_nil
end end
end end
@ -990,7 +990,7 @@ module Arel
manager.from table manager.from table
stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id")) stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
stmt.to_sql.must_be_like %{ _(stmt.to_sql).must_be_like %{
UPDATE "users" SET "id" = 1 UPDATE "users" SET "id" = 1
} }
end end
@ -1001,7 +1001,7 @@ module Arel
manager.from table manager.from table
stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id")) stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id"))
stmt.to_sql.must_be_like %{ UPDATE "users" SET foo = bar } _(stmt.to_sql).must_be_like %{ UPDATE "users" SET foo = bar }
end end
it "copies limits" do it "copies limits" do
@ -1012,7 +1012,7 @@ module Arel
stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id")) stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id"))
stmt.key = table["id"] stmt.key = table["id"]
stmt.to_sql.must_be_like %{ _(stmt.to_sql).must_be_like %{
UPDATE "users" SET foo = bar UPDATE "users" SET foo = bar
WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1) WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1)
} }
@ -1026,7 +1026,7 @@ module Arel
stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id")) stmt = manager.compile_update(Nodes::SqlLiteral.new("foo = bar"), Arel::Attributes::Attribute.new(table, "id"))
stmt.key = table["id"] stmt.key = table["id"]
stmt.to_sql.must_be_like %{ _(stmt.to_sql).must_be_like %{
UPDATE "users" SET foo = bar UPDATE "users" SET foo = bar
WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo) WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo)
} }
@ -1039,7 +1039,7 @@ module Arel
manager.from table manager.from table
stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id")) stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
stmt.to_sql.must_be_like %{ _(stmt.to_sql).must_be_like %{
UPDATE "users" SET "id" = 1 WHERE "users"."id" = 10 UPDATE "users" SET "id" = 1 WHERE "users"."id" = 10
} }
end end
@ -1052,7 +1052,7 @@ module Arel
manager.from table manager.from table
stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id")) stmt = manager.compile_update({ table[:id] => 1 }, Arel::Attributes::Attribute.new(table, "id"))
stmt.to_sql.must_be_like %{ _(stmt.to_sql).must_be_like %{
UPDATE "users" SET "id" = 1 WHERE "users"."id" IN (SELECT "users"."id" FROM "users" WHERE "users"."foo" = 10 LIMIT 42) UPDATE "users" SET "id" = 1 WHERE "users"."id" IN (SELECT "users"."id" FROM "users" WHERE "users"."foo" = 10 LIMIT 42)
} }
end end
@ -1062,20 +1062,20 @@ module Arel
it "takes sql literals" do it "takes sql literals" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
manager.to_sql.must_be_like %{ SELECT * } _(manager.to_sql).must_be_like %{ SELECT * }
end end
it "takes multiple args" do it "takes multiple args" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project Nodes::SqlLiteral.new("foo"), manager.project Nodes::SqlLiteral.new("foo"),
Nodes::SqlLiteral.new("bar") Nodes::SqlLiteral.new("bar")
manager.to_sql.must_be_like %{ SELECT foo, bar } _(manager.to_sql).must_be_like %{ SELECT foo, bar }
end end
it "takes strings" do it "takes strings" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project "*" manager.project "*"
manager.to_sql.must_be_like %{ SELECT * } _(manager.to_sql).must_be_like %{ SELECT * }
end end
end end
@ -1083,7 +1083,7 @@ module Arel
it "reads projections" do it "reads projections" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project Arel.sql("foo"), Arel.sql("bar") manager.project Arel.sql("foo"), Arel.sql("bar")
manager.projections.must_equal [Arel.sql("foo"), Arel.sql("bar")] _(manager.projections).must_equal [Arel.sql("foo"), Arel.sql("bar")]
end end
end end
@ -1092,7 +1092,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.project Arel.sql("foo") manager.project Arel.sql("foo")
manager.projections = [Arel.sql("bar")] manager.projections = [Arel.sql("bar")]
manager.to_sql.must_be_like %{ SELECT bar } _(manager.to_sql).must_be_like %{ SELECT bar }
end end
end end
@ -1104,7 +1104,7 @@ module Arel
manager.where(table["id"].eq(1)) manager.where(table["id"].eq(1))
manager.take 1 manager.take 1
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT "users"."id" SELECT "users"."id"
FROM "users" FROM "users"
WHERE "users"."id" = 1 WHERE "users"."id" = 1
@ -1114,7 +1114,7 @@ module Arel
it "chains" do it "chains" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.take(1).must_equal manager _(manager.take(1)).must_equal manager
end end
it "removes LIMIT when nil is passed" do it "removes LIMIT when nil is passed" do
@ -1133,7 +1133,7 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from(table).project(table["id"]) manager.from(table).project(table["id"])
manager.where(table["id"].eq(1)) manager.where(table["id"].eq(1))
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT "users"."id" SELECT "users"."id"
FROM "users" FROM "users"
WHERE "users"."id" = 1 WHERE "users"."id" = 1
@ -1144,7 +1144,7 @@ module Arel
table = Table.new :users table = Table.new :users
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from(table) manager.from(table)
manager.project(table["id"]).where(table["id"].eq 1).must_equal manager _(manager.project(table["id"]).where(table["id"].eq 1)).must_equal manager
end end
end end
@ -1155,21 +1155,21 @@ module Arel
manager.from table manager.from table
manager.project table["id"] manager.project table["id"]
manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"' _(manager.to_sql).must_be_like 'SELECT "users"."id" FROM "users"'
end end
it "chains" do it "chains" do
table = Table.new :users table = Table.new :users
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.from(table).project(table["id"]).must_equal manager _(manager.from(table).project(table["id"])).must_equal manager
manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"' _(manager.to_sql).must_be_like 'SELECT "users"."id" FROM "users"'
end end
end end
describe "source" do describe "source" do
it "returns the join source of the select core" do it "returns the join source of the select core" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.source.must_equal manager.ast.cores.last.source _(manager.source).must_equal manager.ast.cores.last.source
end end
end end
@ -1178,16 +1178,16 @@ module Arel
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.distinct manager.distinct
manager.ast.cores.last.set_quantifier.class.must_equal Arel::Nodes::Distinct _(manager.ast.cores.last.set_quantifier.class).must_equal Arel::Nodes::Distinct
manager.distinct(false) manager.distinct(false)
manager.ast.cores.last.set_quantifier.must_be_nil _(manager.ast.cores.last.set_quantifier).must_be_nil
end end
it "chains" do it "chains" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.distinct.must_equal manager _(manager.distinct).must_equal manager
manager.distinct(false).must_equal manager _(manager.distinct(false)).must_equal manager
end end
end end
@ -1197,25 +1197,25 @@ module Arel
table = Table.new :users table = Table.new :users
manager.distinct_on(table["id"]) manager.distinct_on(table["id"])
manager.ast.cores.last.set_quantifier.must_equal Arel::Nodes::DistinctOn.new(table["id"]) _(manager.ast.cores.last.set_quantifier).must_equal Arel::Nodes::DistinctOn.new(table["id"])
manager.distinct_on(false) manager.distinct_on(false)
manager.ast.cores.last.set_quantifier.must_be_nil _(manager.ast.cores.last.set_quantifier).must_be_nil
end end
it "chains" do it "chains" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
table = Table.new :users table = Table.new :users
manager.distinct_on(table["id"]).must_equal manager _(manager.distinct_on(table["id"])).must_equal manager
manager.distinct_on(false).must_equal manager _(manager.distinct_on(false)).must_equal manager
end end
end end
describe "comment" do describe "comment" do
it "chains" do it "chains" do
manager = Arel::SelectManager.new manager = Arel::SelectManager.new
manager.comment("selecting").must_equal manager _(manager.comment("selecting")).must_equal manager
end end
it "appends a comment to the generated query" do it "appends a comment to the generated query" do
@ -1224,12 +1224,12 @@ module Arel
manager.from(table).project(table["id"]) manager.from(table).project(table["id"])
manager.comment("selecting") manager.comment("selecting")
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" /* selecting */ SELECT "users"."id" FROM "users" /* selecting */
} }
manager.comment("selecting", "with", "comment") manager.comment("selecting", "with", "comment")
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT "users"."id" FROM "users" /* selecting */ /* with */ /* comment */ SELECT "users"."id" FROM "users" /* selecting */ /* with */ /* comment */
} }
end end

38
activerecord/test/cases/arel/table_test.rb
View File

@ -52,14 +52,14 @@ module Arel
describe "skip" do describe "skip" do
it "should add an offset" do it "should add an offset" do
sm = @relation.skip 2 sm = @relation.skip 2
sm.to_sql.must_be_like "SELECT FROM \"users\" OFFSET 2" _(sm.to_sql).must_be_like "SELECT FROM \"users\" OFFSET 2"
end end
end end
describe "having" do describe "having" do
it "adds a having clause" do it "adds a having clause" do
mgr = @relation.having @relation[:id].eq(10) mgr = @relation.having @relation[:id].eq(10)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT FROM "users" HAVING "users"."id" = 10 SELECT FROM "users" HAVING "users"."id" = 10
} }
end end
@ -70,7 +70,7 @@ module Arel
it "noops on nil" do it "noops on nil" do
mgr = @relation.join nil mgr = @relation.join nil
mgr.to_sql.must_be_like %{ SELECT FROM "users" } _(mgr.to_sql).must_be_like %{ SELECT FROM "users" }
end end
it "raises EmptyJoinError on empty" do it "raises EmptyJoinError on empty" do
@ -84,7 +84,7 @@ module Arel
predicate = @relation[:id].eq(right[:id]) predicate = @relation[:id].eq(right[:id])
mgr = @relation.join(right, Nodes::OuterJoin).on(predicate) mgr = @relation.join(right, Nodes::OuterJoin).on(predicate)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
LEFT OUTER JOIN "users" "users_2" LEFT OUTER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -98,7 +98,7 @@ module Arel
predicate = @relation[:id].eq(right[:id]) predicate = @relation[:id].eq(right[:id])
mgr = @relation.outer_join(right).on(predicate) mgr = @relation.outer_join(right).on(predicate)
mgr.to_sql.must_be_like %{ _(mgr.to_sql).must_be_like %{
SELECT FROM "users" SELECT FROM "users"
LEFT OUTER JOIN "users" "users_2" LEFT OUTER JOIN "users" "users_2"
ON "users"."id" = "users_2"."id" ON "users"."id" = "users_2"."id"
@ -110,7 +110,7 @@ module Arel
describe "group" do describe "group" do
it "should create a group" do it "should create a group" do
manager = @relation.group @relation[:id] manager = @relation.group @relation[:id]
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT FROM "users" GROUP BY "users"."id" SELECT FROM "users" GROUP BY "users"."id"
} }
end end
@ -119,27 +119,27 @@ module Arel
describe "alias" do describe "alias" do
it "should create a node that proxies to a table" do it "should create a node that proxies to a table" do
node = @relation.alias node = @relation.alias
node.name.must_equal "users_2" _(node.name).must_equal "users_2"
node[:id].relation.must_equal node _(node[:id].relation).must_equal node
end end
end end
describe "new" do describe "new" do
it "should accept a hash" do it "should accept a hash" do
rel = Table.new :users, as: "foo" rel = Table.new :users, as: "foo"
rel.table_alias.must_equal "foo" _(rel.table_alias).must_equal "foo"
end end
it "ignores as if it equals name" do it "ignores as if it equals name" do
rel = Table.new :users, as: "users" rel = Table.new :users, as: "users"
rel.table_alias.must_be_nil _(rel.table_alias).must_be_nil
end end
end end
describe "order" do describe "order" do
it "should take an order" do it "should take an order" do
manager = @relation.order "foo" manager = @relation.order "foo"
manager.to_sql.must_be_like %{ SELECT FROM "users" ORDER BY foo } _(manager.to_sql).must_be_like %{ SELECT FROM "users" ORDER BY foo }
end end
end end
@ -147,19 +147,19 @@ module Arel
it "should add a limit" do it "should add a limit" do
manager = @relation.take 1 manager = @relation.take 1
manager.project Nodes::SqlLiteral.new "*" manager.project Nodes::SqlLiteral.new "*"
manager.to_sql.must_be_like %{ SELECT * FROM "users" LIMIT 1 } _(manager.to_sql).must_be_like %{ SELECT * FROM "users" LIMIT 1 }
end end
end end
describe "project" do describe "project" do
it "can project" do it "can project" do
manager = @relation.project Nodes::SqlLiteral.new "*" manager = @relation.project Nodes::SqlLiteral.new "*"
manager.to_sql.must_be_like %{ SELECT * FROM "users" } _(manager.to_sql).must_be_like %{ SELECT * FROM "users" }
end end
it "takes multiple parameters" do it "takes multiple parameters" do
manager = @relation.project Nodes::SqlLiteral.new("*"), Nodes::SqlLiteral.new("*") manager = @relation.project Nodes::SqlLiteral.new("*"), Nodes::SqlLiteral.new("*")
manager.to_sql.must_be_like %{ SELECT *, * FROM "users" } _(manager.to_sql).must_be_like %{ SELECT *, * FROM "users" }
end end
end end
@ -167,8 +167,8 @@ module Arel
it "returns a tree manager" do it "returns a tree manager" do
manager = @relation.where @relation[:id].eq 1 manager = @relation.where @relation[:id].eq 1
manager.project @relation[:id] manager.project @relation[:id]
manager.must_be_kind_of TreeManager _(manager).must_be_kind_of TreeManager
manager.to_sql.must_be_like %{ _(manager.to_sql).must_be_like %{
SELECT "users"."id" SELECT "users"."id"
FROM "users" FROM "users"
WHERE "users"."id" = 1 WHERE "users"."id" = 1
@ -177,18 +177,18 @@ module Arel
end end
it "should have a name" do it "should have a name" do
@relation.name.must_equal "users" _(@relation.name).must_equal "users"
end end
it "should have a table name" do it "should have a table name" do
@relation.table_name.must_equal "users" _(@relation.table_name).must_equal "users"
end end
describe "[]" do describe "[]" do
describe "when given a Symbol" do describe "when given a Symbol" do
it "manufactures an attribute if the symbol names an attribute within the relation" do it "manufactures an attribute if the symbol names an attribute within the relation" do
column = @relation[:id] column = @relation[:id]
column.name.must_equal :id _(column.name).must_equal :id
end end
end end
end end

24
activerecord/test/cases/arel/update_manager_test.rb
View File

@ -15,7 +15,7 @@ module Arel
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table table um.table table
um.set [[table[:name], Arel::Nodes::BindParam.new(1)]] um.set [[table[:name], Arel::Nodes::BindParam.new(1)]]
um.to_sql.must_be_like %{ UPDATE "users" SET "name" = ? } _(um.to_sql).must_be_like %{ UPDATE "users" SET "name" = ? }
end end
it "handles limit properly" do it "handles limit properly" do
@ -34,7 +34,7 @@ module Arel
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table table um.table table
um.set [[table[:name], nil]] um.set [[table[:name], nil]]
um.to_sql.must_be_like %{ UPDATE "users" SET "name" = NULL } _(um.to_sql).must_be_like %{ UPDATE "users" SET "name" = NULL }
end end
it "takes a string" do it "takes a string" do
@ -42,7 +42,7 @@ module Arel
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table table um.table table
um.set Nodes::SqlLiteral.new "foo = bar" um.set Nodes::SqlLiteral.new "foo = bar"
um.to_sql.must_be_like %{ UPDATE "users" SET foo = bar } _(um.to_sql).must_be_like %{ UPDATE "users" SET foo = bar }
end end
it "takes a list of lists" do it "takes a list of lists" do
@ -50,7 +50,7 @@ module Arel
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table table um.table table
um.set [[table[:id], 1], [table[:name], "hello"]] um.set [[table[:id], 1], [table[:name], "hello"]]
um.to_sql.must_be_like %{ _(um.to_sql).must_be_like %{
UPDATE "users" SET "id" = 1, "name" = 'hello' UPDATE "users" SET "id" = 1, "name" = 'hello'
} }
end end
@ -58,7 +58,7 @@ module Arel
it "chains" do it "chains" do
table = Table.new(:users) table = Table.new(:users)
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.set([[table[:id], 1], [table[:name], "hello"]]).must_equal um _(um.set([[table[:id], 1], [table[:name], "hello"]])).must_equal um
end end
end end
@ -66,12 +66,12 @@ module Arel
it "generates an update statement" do it "generates an update statement" do
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table Table.new(:users) um.table Table.new(:users)
um.to_sql.must_be_like %{ UPDATE "users" } _(um.to_sql).must_be_like %{ UPDATE "users" }
end end
it "chains" do it "chains" do
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table(Table.new(:users)).must_equal um _(um.table(Table.new(:users))).must_equal um
end end
it "generates an update statement with joins" do it "generates an update statement with joins" do
@ -84,7 +84,7 @@ module Arel
) )
um.table join_source um.table join_source
um.to_sql.must_be_like %{ UPDATE "users" INNER JOIN "posts" } _(um.to_sql).must_be_like %{ UPDATE "users" INNER JOIN "posts" }
end end
end end
@ -94,7 +94,7 @@ module Arel
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table table um.table table
um.where table[:id].eq(1) um.where table[:id].eq(1)
um.to_sql.must_be_like %{ _(um.to_sql).must_be_like %{
UPDATE "users" WHERE "users"."id" = 1 UPDATE "users" WHERE "users"."id" = 1
} }
end end
@ -103,7 +103,7 @@ module Arel
table = Table.new :users table = Table.new :users
um = Arel::UpdateManager.new um = Arel::UpdateManager.new
um.table table um.table table
um.where(table[:id].eq(1)).must_equal um _(um.where(table[:id].eq(1))).must_equal um
end end
end end
@ -115,11 +115,11 @@ module Arel
end end
it "can be set" do it "can be set" do
@um.ast.key.must_equal @table[:foo] _(@um.ast.key).must_equal @table[:foo]
end end
it "can be accessed" do it "can be accessed" do
@um.key.must_equal @table[:foo] _(@um.key).must_equal @table[:foo]
end end
end end
end end

14
activerecord/test/cases/arel/visitors/ibm_db_test.rb
View File

@ -17,7 +17,7 @@ module Arel
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.limit = Nodes::Limit.new(1) stmt.limit = Nodes::Limit.new(1)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY" _(sql).must_be_like "SELECT FETCH FIRST 1 ROWS ONLY"
end end
it "uses FETCH FIRST n ROWS in updates with a limit" do it "uses FETCH FIRST n ROWS in updates with a limit" do
@ -27,20 +27,20 @@ module Arel
stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1)) stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1))
stmt.key = table[:id] stmt.key = table[:id]
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT \"users\".\"id\" FROM \"users\" FETCH FIRST 1 ROWS ONLY)" _(sql).must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT \"users\".\"id\" FROM \"users\" FETCH FIRST 1 ROWS ONLY)"
end end
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."name", 'Aaron Patterson', 0, 1) = 0 DECODE("users"."name", 'Aaron Patterson', 0, 1) = 0
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."first_name", "users"."last_name", 0, 1) = 0 DECODE("users"."first_name", "users"."last_name", 0, 1) = 0
} }
end end
@ -49,14 +49,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."first_name", "users"."last_name", 0, 1) = 1 DECODE("users"."first_name", "users"."last_name", 0, 1) = 1
} }
end end
@ -65,7 +65,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
end end

20
activerecord/test/cases/arel/visitors/informix_test.rb
View File

@ -17,7 +17,7 @@ module Arel
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.limit = Nodes::Limit.new(1) stmt.limit = Nodes::Limit.new(1)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT FIRST 1" _(sql).must_be_like "SELECT FIRST 1"
end end
it "uses FIRST n in updates with a limit" do it "uses FIRST n in updates with a limit" do
@ -27,14 +27,14 @@ module Arel
stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1)) stmt.limit = Nodes::Limit.new(Nodes.build_quoted(1))
stmt.key = table[:id] stmt.key = table[:id]
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT FIRST 1 \"users\".\"id\" FROM \"users\")" _(sql).must_be_like "UPDATE \"users\" WHERE \"users\".\"id\" IN (SELECT FIRST 1 \"users\".\"id\" FROM \"users\")"
end end
it "uses SKIP n to jump results" do it "uses SKIP n to jump results" do
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.offset = Nodes::Offset.new(10) stmt.offset = Nodes::Offset.new(10)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT SKIP 10" _(sql).must_be_like "SELECT SKIP 10"
end end
it "uses SKIP before FIRST" do it "uses SKIP before FIRST" do
@ -42,7 +42,7 @@ module Arel
stmt.limit = Nodes::Limit.new(1) stmt.limit = Nodes::Limit.new(1)
stmt.offset = Nodes::Offset.new(1) stmt.offset = Nodes::Offset.new(1)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT SKIP 1 FIRST 1" _(sql).must_be_like "SELECT SKIP 1 FIRST 1"
end end
it "uses INNER JOIN to perform joins" do it "uses INNER JOIN to perform joins" do
@ -52,20 +52,20 @@ module Arel
stmt = Nodes::SelectStatement.new([core]) stmt = Nodes::SelectStatement.new([core])
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like 'SELECT FROM "posts" INNER JOIN "comments"' _(sql).must_be_like 'SELECT FROM "posts" INNER JOIN "comments"'
end end
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
CASE WHEN "users"."name" = 'Aaron Patterson' OR ("users"."name" IS NULL AND 'Aaron Patterson' IS NULL) THEN 0 ELSE 1 END = 0 CASE WHEN "users"."name" = 'Aaron Patterson' OR ("users"."name" IS NULL AND 'Aaron Patterson' IS NULL) THEN 0 ELSE 1 END = 0
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 0 CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 0
} }
end end
@ -74,14 +74,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 1 CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 1
} }
end end
@ -90,7 +90,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
end end

26
activerecord/test/cases/arel/visitors/mssql_test.rb
View File

@ -17,7 +17,7 @@ module Arel
it "should not modify query if no offset or limit" do it "should not modify query if no offset or limit" do
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT" _(sql).must_be_like "SELECT"
end end
it "should go over table PK if no .order() or .group()" do it "should go over table PK if no .order() or .group()" do
@ -25,7 +25,7 @@ module Arel
stmt.cores.first.from = @table stmt.cores.first.from = @table
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY \"users\".\"id\") as _row_num FROM \"users\") as _t WHERE _row_num BETWEEN 1 AND 10" _(sql).must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY \"users\".\"id\") as _row_num FROM \"users\") as _t WHERE _row_num BETWEEN 1 AND 10"
end end
it "caches the PK lookup for order" do it "caches the PK lookup for order" do
@ -53,7 +53,7 @@ module Arel
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "DELETE TOP (10) FROM \"users\"" _(sql).must_be_like "DELETE TOP (10) FROM \"users\""
end end
it "should go over query ORDER BY if .order()" do it "should go over query ORDER BY if .order()" do
@ -61,7 +61,7 @@ module Arel
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
stmt.orders << Nodes::SqlLiteral.new("order_by") stmt.orders << Nodes::SqlLiteral.new("order_by")
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY order_by) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10" _(sql).must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY order_by) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10"
end end
it "should go over query GROUP BY if no .order() and there is .group()" do it "should go over query GROUP BY if no .order() and there is .group()" do
@ -69,7 +69,7 @@ module Arel
stmt.cores.first.groups << Nodes::SqlLiteral.new("group_by") stmt.cores.first.groups << Nodes::SqlLiteral.new("group_by")
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY group_by) as _row_num GROUP BY group_by) as _t WHERE _row_num BETWEEN 1 AND 10" _(sql).must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY group_by) as _row_num GROUP BY group_by) as _t WHERE _row_num BETWEEN 1 AND 10"
end end
it "should use BETWEEN if both .limit() and .offset" do it "should use BETWEEN if both .limit() and .offset" do
@ -77,14 +77,14 @@ module Arel
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
stmt.offset = Nodes::Offset.new(20) stmt.offset = Nodes::Offset.new(20)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 21 AND 30" _(sql).must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 21 AND 30"
end end
it "should use >= if only .offset" do it "should use >= if only .offset" do
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.offset = Nodes::Offset.new(20) stmt.offset = Nodes::Offset.new(20)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num >= 21" _(sql).must_be_like "SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num >= 21"
end end
it "should generate subquery for .count" do it "should generate subquery for .count" do
@ -92,20 +92,20 @@ module Arel
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
stmt.cores.first.projections << Nodes::Count.new("*") stmt.cores.first.projections << Nodes::Count.new("*")
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT COUNT(1) as count_id FROM (SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10) AS subquery" _(sql).must_be_like "SELECT COUNT(1) as count_id FROM (SELECT _t.* FROM (SELECT ROW_NUMBER() OVER (ORDER BY ) as _row_num) as _t WHERE _row_num BETWEEN 1 AND 10) AS subquery"
end end
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
EXISTS (VALUES ("users"."name") INTERSECT VALUES ('Aaron Patterson')) EXISTS (VALUES ("users"."name") INTERSECT VALUES ('Aaron Patterson'))
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
EXISTS (VALUES ("users"."first_name") INTERSECT VALUES ("users"."last_name")) EXISTS (VALUES ("users"."first_name") INTERSECT VALUES ("users"."last_name"))
} }
end end
@ -114,14 +114,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
NOT EXISTS (VALUES ("users"."first_name") INTERSECT VALUES ("users"."last_name")) NOT EXISTS (VALUES ("users"."first_name") INTERSECT VALUES ("users"."last_name"))
} }
end end
@ -130,7 +130,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
end end

34
activerecord/test/cases/arel/visitors/mysql_test.rb
View File

@ -20,7 +20,7 @@ module Arel
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.offset = Nodes::Offset.new(1) stmt.offset = Nodes::Offset.new(1)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1" _(sql).must_be_like "SELECT FROM DUAL LIMIT 18446744073709551615 OFFSET 1"
end end
it "should escape LIMIT" do it "should escape LIMIT" do
@ -33,18 +33,18 @@ module Arel
it "uses DUAL for empty from" do it "uses DUAL for empty from" do
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT FROM DUAL" _(sql).must_be_like "SELECT FROM DUAL"
end end
describe "locking" do describe "locking" do
it "defaults to FOR UPDATE when locking" do it "defaults to FOR UPDATE when locking" do
node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
compile(node).must_be_like "FOR UPDATE" _(compile(node)).must_be_like "FOR UPDATE"
end end
it "allows a custom string to be used as a lock" do it "allows a custom string to be used as a lock" do
node = Nodes::Lock.new(Arel.sql("LOCK IN SHARE MODE")) node = Nodes::Lock.new(Arel.sql("LOCK IN SHARE MODE"))
compile(node).must_be_like "LOCK IN SHARE MODE" _(compile(node)).must_be_like "LOCK IN SHARE MODE"
end end
end end
@ -52,7 +52,7 @@ module Arel
it "concats columns" do it "concats columns" do
@table = Table.new(:users) @table = Table.new(:users)
query = @table[:name].concat(@table[:name]) query = @table[:name].concat(@table[:name])
compile(query).must_be_like %{ _(compile(query)).must_be_like %{
CONCAT("users"."name", "users"."name") CONCAT("users"."name", "users"."name")
} }
end end
@ -60,7 +60,7 @@ module Arel
it "concats a string" do it "concats a string" do
@table = Table.new(:users) @table = Table.new(:users)
query = @table[:name].concat(Nodes.build_quoted("abc")) query = @table[:name].concat(Nodes.build_quoted("abc"))
compile(query).must_be_like %{ _(compile(query)).must_be_like %{
CONCAT("users"."name", 'abc') CONCAT("users"."name", 'abc')
} }
end end
@ -69,14 +69,14 @@ module Arel
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."name" <=> 'Aaron Patterson' "users"."name" <=> 'Aaron Patterson'
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."first_name" <=> "users"."last_name" "users"."first_name" <=> "users"."last_name"
} }
end end
@ -85,14 +85,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" <=> NULL } _(sql).must_be_like %{ "users"."name" <=> NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
NOT "users"."first_name" <=> "users"."last_name" NOT "users"."first_name" <=> "users"."last_name"
} }
end end
@ -101,7 +101,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ NOT "users"."name" <=> NULL } _(sql).must_be_like %{ NOT "users"."name" <=> NULL }
end end
end end
@ -113,8 +113,8 @@ module Arel
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].matches_regexp("foo.*") node = @table[:name].matches_regexp("foo.*")
node.must_be_kind_of Nodes::Regexp _(node).must_be_kind_of Nodes::Regexp
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" REGEXP 'foo.*' "users"."name" REGEXP 'foo.*'
} }
end end
@ -122,7 +122,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*")) subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" REGEXP 'foo.*') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" REGEXP 'foo.*')
} }
end end
@ -136,8 +136,8 @@ module Arel
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].does_not_match_regexp("foo.*") node = @table[:name].does_not_match_regexp("foo.*")
node.must_be_kind_of Nodes::NotRegexp _(node).must_be_kind_of Nodes::NotRegexp
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" NOT REGEXP 'foo.*' "users"."name" NOT REGEXP 'foo.*'
} }
end end
@ -145,7 +145,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*")) subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT REGEXP 'foo.*') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT REGEXP 'foo.*')
} }
end end

18
activerecord/test/cases/arel/visitors/oracle12_test.rb
View File

@ -18,7 +18,7 @@ module Arel
left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10") left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20") right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
sql = compile Nodes::Except.new(left, right) sql = compile Nodes::Except.new(left, right)
sql.must_be_like %{ _(sql).must_be_like %{
( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 ) ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
} }
end end
@ -28,7 +28,7 @@ module Arel
stmt.offset = Nodes::Offset.new(1) stmt.offset = Nodes::Offset.new(1)
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like "SELECT OFFSET 1 ROWS FETCH FIRST 10 ROWS ONLY" _(sql).must_be_like "SELECT OFFSET 1 ROWS FETCH FIRST 10 ROWS ONLY"
end end
describe "locking" do describe "locking" do
@ -43,7 +43,7 @@ module Arel
it "defaults to FOR UPDATE when locking" do it "defaults to FOR UPDATE when locking" do
node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
compile(node).must_be_like "FOR UPDATE" _(compile(node)).must_be_like "FOR UPDATE"
end end
end end
@ -51,7 +51,7 @@ module Arel
it "increments each bind param" do it "increments each bind param" do
query = @table[:name].eq(Arel::Nodes::BindParam.new(1)) query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
.and(@table[:id].eq(Arel::Nodes::BindParam.new(1))) .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
compile(query).must_be_like %{ _(compile(query)).must_be_like %{
"users"."name" = :a1 AND "users"."id" = :a2 "users"."name" = :a1 AND "users"."id" = :a2
} }
end end
@ -60,14 +60,14 @@ module Arel
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."name", 'Aaron Patterson', 0, 1) = 0 DECODE("users"."name", 'Aaron Patterson', 0, 1) = 0
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."first_name", "users"."last_name", 0, 1) = 0 DECODE("users"."first_name", "users"."last_name", 0, 1) = 0
} }
end end
@ -76,14 +76,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."first_name", "users"."last_name", 0, 1) = 1 DECODE("users"."first_name", "users"."last_name", 0, 1) = 1
} }
end end
@ -92,7 +92,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
end end

42
activerecord/test/cases/arel/visitors/oracle_test.rb
View File

@ -21,7 +21,7 @@ module Arel
stmt.cores.first.projections << Nodes::SqlLiteral.new(select) stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
stmt.orders << Nodes::SqlLiteral.new("foo") stmt.orders << Nodes::SqlLiteral.new("foo")
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like %{ _(sql).must_be_like %{
SELECT #{select} ORDER BY alias_0__ SELECT #{select} ORDER BY alias_0__
} }
end end
@ -35,7 +35,7 @@ module Arel
sql = compile(stmt) sql = compile(stmt)
sql2 = compile(stmt) sql2 = compile(stmt)
sql.must_equal sql2 _(sql).must_equal sql2
end end
it "splits orders with commas" do it "splits orders with commas" do
@ -45,7 +45,7 @@ module Arel
stmt.cores.first.projections << Nodes::SqlLiteral.new(select) stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
stmt.orders << Nodes::SqlLiteral.new("foo, bar") stmt.orders << Nodes::SqlLiteral.new("foo, bar")
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like %{ _(sql).must_be_like %{
SELECT #{select} ORDER BY alias_0__, alias_1__ SELECT #{select} ORDER BY alias_0__, alias_1__
} }
end end
@ -57,7 +57,7 @@ module Arel
stmt.cores.first.projections << Nodes::SqlLiteral.new(select) stmt.cores.first.projections << Nodes::SqlLiteral.new(select)
stmt.orders << Nodes::SqlLiteral.new("NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)") stmt.orders << Nodes::SqlLiteral.new("NVL(LOWER(bar, foo), foo) DESC, UPPER(baz)")
sql = compile(stmt) sql = compile(stmt)
sql.must_be_like %{ _(sql).must_be_like %{
SELECT #{select} ORDER BY alias_0__ DESC, alias_1__ SELECT #{select} ORDER BY alias_0__ DESC, alias_1__
} }
end end
@ -68,7 +68,7 @@ module Arel
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile stmt sql = compile stmt
sql.must_be_like %{ SELECT WHERE ROWNUM <= 10 } _(sql).must_be_like %{ SELECT WHERE ROWNUM <= 10 }
end end
it "is idempotent" do it "is idempotent" do
@ -77,7 +77,7 @@ module Arel
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile stmt sql = compile stmt
sql2 = compile stmt sql2 = compile stmt
sql.must_equal sql2 _(sql).must_equal sql2
end end
it "creates a subquery when there is order_by" do it "creates a subquery when there is order_by" do
@ -85,7 +85,7 @@ module Arel
stmt.orders << Nodes::SqlLiteral.new("foo") stmt.orders << Nodes::SqlLiteral.new("foo")
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile stmt sql = compile stmt
sql.must_be_like %{ _(sql).must_be_like %{
SELECT * FROM (SELECT ORDER BY foo ) WHERE ROWNUM <= 10 SELECT * FROM (SELECT ORDER BY foo ) WHERE ROWNUM <= 10
} }
end end
@ -95,7 +95,7 @@ module Arel
stmt.cores.first.groups << Nodes::SqlLiteral.new("foo") stmt.cores.first.groups << Nodes::SqlLiteral.new("foo")
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
sql = compile stmt sql = compile stmt
sql.must_be_like %{ _(sql).must_be_like %{
SELECT * FROM (SELECT GROUP BY foo ) WHERE ROWNUM <= 10 SELECT * FROM (SELECT GROUP BY foo ) WHERE ROWNUM <= 10
} }
end end
@ -106,7 +106,7 @@ module Arel
stmt.cores.first.projections << Nodes::SqlLiteral.new("id") stmt.cores.first.projections << Nodes::SqlLiteral.new("id")
stmt.limit = Arel::Nodes::Limit.new(10) stmt.limit = Arel::Nodes::Limit.new(10)
sql = compile stmt sql = compile stmt
sql.must_be_like %{ _(sql).must_be_like %{
SELECT * FROM (SELECT DISTINCT id ) WHERE ROWNUM <= 10 SELECT * FROM (SELECT DISTINCT id ) WHERE ROWNUM <= 10
} }
end end
@ -116,7 +116,7 @@ module Arel
stmt.limit = Nodes::Limit.new(10) stmt.limit = Nodes::Limit.new(10)
stmt.offset = Nodes::Offset.new(10) stmt.offset = Nodes::Offset.new(10)
sql = compile stmt sql = compile stmt
sql.must_be_like %{ _(sql).must_be_like %{
SELECT * FROM ( SELECT * FROM (
SELECT raw_sql_.*, rownum raw_rnum_ SELECT raw_sql_.*, rownum raw_rnum_
FROM (SELECT ) raw_sql_ FROM (SELECT ) raw_sql_
@ -131,7 +131,7 @@ module Arel
stmt.limit = Nodes::Limit.new(Nodes::BindParam.new(1)) stmt.limit = Nodes::Limit.new(Nodes::BindParam.new(1))
stmt.offset = Nodes::Offset.new(Nodes::BindParam.new(1)) stmt.offset = Nodes::Offset.new(Nodes::BindParam.new(1))
sql = compile stmt sql = compile stmt
sql.must_be_like %{ _(sql).must_be_like %{
SELECT * FROM ( SELECT * FROM (
SELECT raw_sql_.*, rownum raw_rnum_ SELECT raw_sql_.*, rownum raw_rnum_
FROM (SELECT ) raw_sql_ FROM (SELECT ) raw_sql_
@ -147,7 +147,7 @@ module Arel
stmt.offset = Nodes::Offset.new(10) stmt.offset = Nodes::Offset.new(10)
sql = compile stmt sql = compile stmt
sql2 = compile stmt sql2 = compile stmt
sql.must_equal sql2 _(sql).must_equal sql2
end end
end end
@ -156,7 +156,7 @@ module Arel
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.offset = Nodes::Offset.new(10) stmt.offset = Nodes::Offset.new(10)
sql = compile stmt sql = compile stmt
sql.must_be_like %{ _(sql).must_be_like %{
SELECT * FROM ( SELECT * FROM (
SELECT raw_sql_.*, rownum raw_rnum_ SELECT raw_sql_.*, rownum raw_rnum_
FROM (SELECT) raw_sql_ FROM (SELECT) raw_sql_
@ -171,7 +171,7 @@ module Arel
left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10") left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20") right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
sql = compile Nodes::Except.new(left, right) sql = compile Nodes::Except.new(left, right)
sql.must_be_like %{ _(sql).must_be_like %{
( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 ) ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
} }
end end
@ -179,7 +179,7 @@ module Arel
describe "locking" do describe "locking" do
it "defaults to FOR UPDATE when locking" do it "defaults to FOR UPDATE when locking" do
node = Nodes::Lock.new(Arel.sql("FOR UPDATE")) node = Nodes::Lock.new(Arel.sql("FOR UPDATE"))
compile(node).must_be_like "FOR UPDATE" _(compile(node)).must_be_like "FOR UPDATE"
end end
end end
@ -187,7 +187,7 @@ module Arel
it "increments each bind param" do it "increments each bind param" do
query = @table[:name].eq(Arel::Nodes::BindParam.new(1)) query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
.and(@table[:id].eq(Arel::Nodes::BindParam.new(1))) .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
compile(query).must_be_like %{ _(compile(query)).must_be_like %{
"users"."name" = :a1 AND "users"."id" = :a2 "users"."name" = :a1 AND "users"."id" = :a2
} }
end end
@ -196,14 +196,14 @@ module Arel
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."name", 'Aaron Patterson', 0, 1) = 0 DECODE("users"."name", 'Aaron Patterson', 0, 1) = 0
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."first_name", "users"."last_name", 0, 1) = 0 DECODE("users"."first_name", "users"."last_name", 0, 1) = 0
} }
end end
@ -212,14 +212,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
DECODE("users"."first_name", "users"."last_name", 0, 1) = 1 DECODE("users"."first_name", "users"."last_name", 0, 1) = 1
} }
end end
@ -228,7 +228,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
end end

92
activerecord/test/cases/arel/visitors/postgres_test.rb
View File

@ -17,14 +17,14 @@ module Arel
describe "locking" do describe "locking" do
it "defaults to FOR UPDATE" do it "defaults to FOR UPDATE" do
compile(Nodes::Lock.new(Arel.sql("FOR UPDATE"))).must_be_like %{ _(compile(Nodes::Lock.new(Arel.sql("FOR UPDATE")))).must_be_like %{
FOR UPDATE FOR UPDATE
} }
end end
it "allows a custom string to be used as a lock" do it "allows a custom string to be used as a lock" do
node = Nodes::Lock.new(Arel.sql("FOR SHARE")) node = Nodes::Lock.new(Arel.sql("FOR SHARE"))
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
FOR SHARE FOR SHARE
} }
end end
@ -54,14 +54,14 @@ module Arel
it "encloses LATERAL queries in parens" do it "encloses LATERAL queries in parens" do
subquery = @table.project(:id).where(@table[:name].matches("foo%")) subquery = @table.project(:id).where(@table[:name].matches("foo%"))
compile(subquery.lateral).must_be_like %{ _(compile(subquery.lateral)).must_be_like %{
LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
} }
end end
it "produces LATERAL queries with alias" do it "produces LATERAL queries with alias" do
subquery = @table.project(:id).where(@table[:name].matches("foo%")) subquery = @table.project(:id).where(@table[:name].matches("foo%"))
compile(subquery.lateral("bar")).must_be_like %{ _(compile(subquery.lateral("bar"))).must_be_like %{
LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') bar LATERAL (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') bar
} }
end end
@ -69,24 +69,24 @@ module Arel
describe "Nodes::Matches" do describe "Nodes::Matches" do
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].matches("foo%") node = @table[:name].matches("foo%")
node.must_be_kind_of Nodes::Matches _(node).must_be_kind_of Nodes::Matches
node.case_sensitive.must_equal(false) _(node.case_sensitive).must_equal(false)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" ILIKE 'foo%' "users"."name" ILIKE 'foo%'
} }
end end
it "should know how to visit case sensitive" do it "should know how to visit case sensitive" do
node = @table[:name].matches("foo%", nil, true) node = @table[:name].matches("foo%", nil, true)
node.case_sensitive.must_equal(true) _(node.case_sensitive).must_equal(true)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" LIKE 'foo%' "users"."name" LIKE 'foo%'
} }
end end
it "can handle ESCAPE" do it "can handle ESCAPE" do
node = @table[:name].matches("foo!%", "!") node = @table[:name].matches("foo!%", "!")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" ILIKE 'foo!%' ESCAPE '!' "users"."name" ILIKE 'foo!%' ESCAPE '!'
} }
end end
@ -94,7 +94,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].matches("foo%")) subquery = @table.project(:id).where(@table[:name].matches("foo%"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ILIKE 'foo%')
} }
end end
@ -103,24 +103,24 @@ module Arel
describe "Nodes::DoesNotMatch" do describe "Nodes::DoesNotMatch" do
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].does_not_match("foo%") node = @table[:name].does_not_match("foo%")
node.must_be_kind_of Nodes::DoesNotMatch _(node).must_be_kind_of Nodes::DoesNotMatch
node.case_sensitive.must_equal(false) _(node.case_sensitive).must_equal(false)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" NOT ILIKE 'foo%' "users"."name" NOT ILIKE 'foo%'
} }
end end
it "should know how to visit case sensitive" do it "should know how to visit case sensitive" do
node = @table[:name].does_not_match("foo%", nil, true) node = @table[:name].does_not_match("foo%", nil, true)
node.case_sensitive.must_equal(true) _(node.case_sensitive).must_equal(true)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" NOT LIKE 'foo%' "users"."name" NOT LIKE 'foo%'
} }
end end
it "can handle ESCAPE" do it "can handle ESCAPE" do
node = @table[:name].does_not_match("foo!%", "!") node = @table[:name].does_not_match("foo!%", "!")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" NOT ILIKE 'foo!%' ESCAPE '!' "users"."name" NOT ILIKE 'foo!%' ESCAPE '!'
} }
end end
@ -128,7 +128,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].does_not_match("foo%")) subquery = @table.project(:id).where(@table[:name].does_not_match("foo%"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT ILIKE 'foo%') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT ILIKE 'foo%')
} }
end end
@ -137,18 +137,18 @@ module Arel
describe "Nodes::Regexp" do describe "Nodes::Regexp" do
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].matches_regexp("foo.*") node = @table[:name].matches_regexp("foo.*")
node.must_be_kind_of Nodes::Regexp _(node).must_be_kind_of Nodes::Regexp
node.case_sensitive.must_equal(true) _(node.case_sensitive).must_equal(true)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" ~ 'foo.*' "users"."name" ~ 'foo.*'
} }
end end
it "can handle case insensitive" do it "can handle case insensitive" do
node = @table[:name].matches_regexp("foo.*", false) node = @table[:name].matches_regexp("foo.*", false)
node.must_be_kind_of Nodes::Regexp _(node).must_be_kind_of Nodes::Regexp
node.case_sensitive.must_equal(false) _(node.case_sensitive).must_equal(false)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" ~* 'foo.*' "users"."name" ~* 'foo.*'
} }
end end
@ -156,7 +156,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*")) subquery = @table.project(:id).where(@table[:name].matches_regexp("foo.*"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ~ 'foo.*') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" ~ 'foo.*')
} }
end end
@ -165,17 +165,17 @@ module Arel
describe "Nodes::NotRegexp" do describe "Nodes::NotRegexp" do
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].does_not_match_regexp("foo.*") node = @table[:name].does_not_match_regexp("foo.*")
node.must_be_kind_of Nodes::NotRegexp _(node).must_be_kind_of Nodes::NotRegexp
node.case_sensitive.must_equal(true) _(node.case_sensitive).must_equal(true)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" !~ 'foo.*' "users"."name" !~ 'foo.*'
} }
end end
it "can handle case insensitive" do it "can handle case insensitive" do
node = @table[:name].does_not_match_regexp("foo.*", false) node = @table[:name].does_not_match_regexp("foo.*", false)
node.case_sensitive.must_equal(false) _(node.case_sensitive).must_equal(false)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" !~* 'foo.*' "users"."name" !~* 'foo.*'
} }
end end
@ -183,7 +183,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*")) subquery = @table.project(:id).where(@table[:name].does_not_match_regexp("foo.*"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" !~ 'foo.*') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" !~ 'foo.*')
} }
end end
@ -193,7 +193,7 @@ module Arel
it "increments each bind param" do it "increments each bind param" do
query = @table[:name].eq(Arel::Nodes::BindParam.new(1)) query = @table[:name].eq(Arel::Nodes::BindParam.new(1))
.and(@table[:id].eq(Arel::Nodes::BindParam.new(1))) .and(@table[:id].eq(Arel::Nodes::BindParam.new(1)))
compile(query).must_be_like %{ _(compile(query)).must_be_like %{
"users"."name" = $1 AND "users"."id" = $2 "users"."name" = $1 AND "users"."id" = $2
} }
end end
@ -202,7 +202,7 @@ module Arel
describe "Nodes::Cube" do describe "Nodes::Cube" do
it "should know how to visit with array arguments" do it "should know how to visit with array arguments" do
node = Arel::Nodes::Cube.new([@table[:name], @table[:bool]]) node = Arel::Nodes::Cube.new([@table[:name], @table[:bool]])
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CUBE( "users"."name", "users"."bool" ) CUBE( "users"."name", "users"."bool" )
} }
end end
@ -210,7 +210,7 @@ module Arel
it "should know how to visit with CubeDimension Argument" do it "should know how to visit with CubeDimension Argument" do
dimensions = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]]) dimensions = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
node = Arel::Nodes::Cube.new(dimensions) node = Arel::Nodes::Cube.new(dimensions)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CUBE( "users"."name", "users"."bool" ) CUBE( "users"."name", "users"."bool" )
} }
end end
@ -219,7 +219,7 @@ module Arel
dim1 = Arel::Nodes::GroupingElement.new(@table[:name]) dim1 = Arel::Nodes::GroupingElement.new(@table[:name])
dim2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]]) dim2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
node = Arel::Nodes::Cube.new([dim1, dim2]) node = Arel::Nodes::Cube.new([dim1, dim2])
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CUBE( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) ) CUBE( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
} }
end end
@ -228,7 +228,7 @@ module Arel
describe "Nodes::GroupingSet" do describe "Nodes::GroupingSet" do
it "should know how to visit with array arguments" do it "should know how to visit with array arguments" do
node = Arel::Nodes::GroupingSet.new([@table[:name], @table[:bool]]) node = Arel::Nodes::GroupingSet.new([@table[:name], @table[:bool]])
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
GROUPING SETS( "users"."name", "users"."bool" ) GROUPING SETS( "users"."name", "users"."bool" )
} }
end end
@ -236,7 +236,7 @@ module Arel
it "should know how to visit with CubeDimension Argument" do it "should know how to visit with CubeDimension Argument" do
group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]]) group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
node = Arel::Nodes::GroupingSet.new(group) node = Arel::Nodes::GroupingSet.new(group)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
GROUPING SETS( "users"."name", "users"."bool" ) GROUPING SETS( "users"."name", "users"."bool" )
} }
end end
@ -245,7 +245,7 @@ module Arel
group1 = Arel::Nodes::GroupingElement.new(@table[:name]) group1 = Arel::Nodes::GroupingElement.new(@table[:name])
group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]]) group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
node = Arel::Nodes::GroupingSet.new([group1, group2]) node = Arel::Nodes::GroupingSet.new([group1, group2])
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
GROUPING SETS( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) ) GROUPING SETS( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
} }
end end
@ -254,7 +254,7 @@ module Arel
describe "Nodes::RollUp" do describe "Nodes::RollUp" do
it "should know how to visit with array arguments" do it "should know how to visit with array arguments" do
node = Arel::Nodes::RollUp.new([@table[:name], @table[:bool]]) node = Arel::Nodes::RollUp.new([@table[:name], @table[:bool]])
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
ROLLUP( "users"."name", "users"."bool" ) ROLLUP( "users"."name", "users"."bool" )
} }
end end
@ -262,7 +262,7 @@ module Arel
it "should know how to visit with CubeDimension Argument" do it "should know how to visit with CubeDimension Argument" do
group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]]) group = Arel::Nodes::GroupingElement.new([@table[:name], @table[:bool]])
node = Arel::Nodes::RollUp.new(group) node = Arel::Nodes::RollUp.new(group)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
ROLLUP( "users"."name", "users"."bool" ) ROLLUP( "users"."name", "users"."bool" )
} }
end end
@ -271,7 +271,7 @@ module Arel
group1 = Arel::Nodes::GroupingElement.new(@table[:name]) group1 = Arel::Nodes::GroupingElement.new(@table[:name])
group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]]) group2 = Arel::Nodes::GroupingElement.new([@table[:bool], @table[:created_at]])
node = Arel::Nodes::RollUp.new([group1, group2]) node = Arel::Nodes::RollUp.new([group1, group2])
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
ROLLUP( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) ) ROLLUP( ( "users"."name" ), ( "users"."bool", "users"."created_at" ) )
} }
end end
@ -280,14 +280,14 @@ module Arel
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."name" IS NOT DISTINCT FROM 'Aaron Patterson' "users"."name" IS NOT DISTINCT FROM 'Aaron Patterson'
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."first_name" IS NOT DISTINCT FROM "users"."last_name" "users"."first_name" IS NOT DISTINCT FROM "users"."last_name"
} }
end end
@ -296,14 +296,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT DISTINCT FROM NULL } _(sql).must_be_like %{ "users"."name" IS NOT DISTINCT FROM NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."first_name" IS DISTINCT FROM "users"."last_name" "users"."first_name" IS DISTINCT FROM "users"."last_name"
} }
end end
@ -312,7 +312,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS DISTINCT FROM NULL } _(sql).must_be_like %{ "users"."name" IS DISTINCT FROM NULL }
end end
end end
end end

12
activerecord/test/cases/arel/visitors/sqlite_test.rb
View File

@ -17,7 +17,7 @@ module Arel
stmt = Nodes::SelectStatement.new stmt = Nodes::SelectStatement.new
stmt.offset = Nodes::Offset.new(1) stmt.offset = Nodes::Offset.new(1)
sql = @visitor.accept(stmt, Collectors::SQLString.new).value sql = @visitor.accept(stmt, Collectors::SQLString.new).value
sql.must_be_like "SELECT LIMIT -1 OFFSET 1" _(sql).must_be_like "SELECT LIMIT -1 OFFSET 1"
end end
it "does not support locking" do it "does not support locking" do
@ -35,14 +35,14 @@ module Arel
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."name" IS 'Aaron Patterson' "users"."name" IS 'Aaron Patterson'
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."first_name" IS "users"."last_name" "users"."first_name" IS "users"."last_name"
} }
end end
@ -51,14 +51,14 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."first_name" IS NOT "users"."last_name" "users"."first_name" IS NOT "users"."last_name"
} }
end end
@ -67,7 +67,7 @@ module Arel
@table = Table.new(:users) @table = Table.new(:users)
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
end end

158
activerecord/test/cases/arel/visitors/to_sql_test.rb
View File

@ -20,14 +20,14 @@ module Arel
it "works with BindParams" do it "works with BindParams" do
node = Nodes::BindParam.new(1) node = Nodes::BindParam.new(1)
sql = compile node sql = compile node
sql.must_be_like "?" _(sql).must_be_like "?"
end end
it "does not quote BindParams used as part of a ValuesList" do it "does not quote BindParams used as part of a ValuesList" do
bp = Nodes::BindParam.new(1) bp = Nodes::BindParam.new(1)
values = Nodes::ValuesList.new([[bp]]) values = Nodes::ValuesList.new([[bp]])
sql = compile values sql = compile values
sql.must_be_like "VALUES (?)" _(sql).must_be_like "VALUES (?)"
end end
it "can define a dispatch method" do it "can define a dispatch method" do
@ -49,7 +49,7 @@ module Arel
it "should not quote sql literals" do it "should not quote sql literals" do
node = @table[Arel.star] node = @table[Arel.star]
sql = compile node sql = compile node
sql.must_be_like '"users".*' _(sql).must_be_like '"users".*'
end end
it "should visit named functions" do it "should visit named functions" do
@ -60,13 +60,13 @@ module Arel
it "should chain predications on named functions" do it "should chain predications on named functions" do
function = Nodes::NamedFunction.new("omg", [Arel.star]) function = Nodes::NamedFunction.new("omg", [Arel.star])
sql = compile(function.eq(2)) sql = compile(function.eq(2))
sql.must_be_like %{ omg(*) = 2 } _(sql).must_be_like %{ omg(*) = 2 }
end end
it "should handle nil with named functions" do it "should handle nil with named functions" do
function = Nodes::NamedFunction.new("omg", [Arel.star]) function = Nodes::NamedFunction.new("omg", [Arel.star])
sql = compile(function.eq(nil)) sql = compile(function.eq(nil))
sql.must_be_like %{ omg(*) IS NULL } _(sql).must_be_like %{ omg(*) IS NULL }
end end
it "should visit built-in functions" do it "should visit built-in functions" do
@ -116,7 +116,7 @@ module Arel
describe "Nodes::Equality" do describe "Nodes::Equality" do
it "should escape strings" do it "should escape strings" do
test = Table.new(:users)[:name].eq "Aaron Patterson" test = Table.new(:users)[:name].eq "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"users"."name" = 'Aaron Patterson' "users"."name" = 'Aaron Patterson'
} }
end end
@ -125,19 +125,19 @@ module Arel
table = Table.new(:users) table = Table.new(:users)
val = Nodes.build_quoted(false, table[:active]) val = Nodes.build_quoted(false, table[:active])
sql = compile Nodes::Equality.new(val, val) sql = compile Nodes::Equality.new(val, val)
sql.must_be_like %{ 'f' = 'f' } _(sql).must_be_like %{ 'f' = 'f' }
end end
it "should handle nil" do it "should handle nil" do
sql = compile Nodes::Equality.new(@table[:name], nil) sql = compile Nodes::Equality.new(@table[:name], nil)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::Grouping" do describe "Nodes::Grouping" do
it "wraps nested groupings in brackets only once" do it "wraps nested groupings in brackets only once" do
sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted("foo"))) sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted("foo")))
sql.must_equal "('foo')" _(sql).must_equal "('foo')"
end end
end end
@ -145,27 +145,27 @@ module Arel
it "should handle false" do it "should handle false" do
val = Nodes.build_quoted(false, @table[:active]) val = Nodes.build_quoted(false, @table[:active])
sql = compile Nodes::NotEqual.new(@table[:active], val) sql = compile Nodes::NotEqual.new(@table[:active], val)
sql.must_be_like %{ "users"."active" != 'f' } _(sql).must_be_like %{ "users"."active" != 'f' }
end end
it "should handle nil" do it "should handle nil" do
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::NotEqual.new(@table[:name], val) sql = compile Nodes::NotEqual.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
describe "Nodes::IsNotDistinctFrom" do describe "Nodes::IsNotDistinctFrom" do
it "should construct a valid generic SQL statement" do it "should construct a valid generic SQL statement" do
test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson" test = Table.new(:users)[:name].is_not_distinct_from "Aaron Patterson"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
CASE WHEN "users"."name" = 'Aaron Patterson' OR ("users"."name" IS NULL AND 'Aaron Patterson' IS NULL) THEN 0 ELSE 1 END = 0 CASE WHEN "users"."name" = 'Aaron Patterson' OR ("users"."name" IS NULL AND 'Aaron Patterson' IS NULL) THEN 0 ELSE 1 END = 0
} }
end end
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_not_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 0 CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 0
} }
end end
@ -173,14 +173,14 @@ module Arel
it "should handle nil" do it "should handle nil" do
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsNotDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NULL } _(sql).must_be_like %{ "users"."name" IS NULL }
end end
end end
describe "Nodes::IsDistinctFrom" do describe "Nodes::IsDistinctFrom" do
it "should handle column names on both sides" do it "should handle column names on both sides" do
test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name] test = Table.new(:users)[:first_name].is_distinct_from Table.new(:users)[:last_name]
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 1 CASE WHEN "users"."first_name" = "users"."last_name" OR ("users"."first_name" IS NULL AND "users"."last_name" IS NULL) THEN 0 ELSE 1 END = 1
} }
end end
@ -188,7 +188,7 @@ module Arel
it "should handle nil" do it "should handle nil" do
val = Nodes.build_quoted(nil, @table[:active]) val = Nodes.build_quoted(nil, @table[:active])
sql = compile Nodes::IsDistinctFrom.new(@table[:name], val) sql = compile Nodes::IsDistinctFrom.new(@table[:name], val)
sql.must_be_like %{ "users"."name" IS NOT NULL } _(sql).must_be_like %{ "users"."name" IS NOT NULL }
end end
end end
@ -199,12 +199,12 @@ module Arel
].each do |obj| ].each do |obj|
val = Nodes.build_quoted(obj, @table[:active]) val = Nodes.build_quoted(obj, @table[:active])
sql = compile Nodes::NotEqual.new(@table[:name], val) sql = compile Nodes::NotEqual.new(@table[:name], val)
sql.must_be_like %{ "users"."name" != ':\\'(' } _(sql).must_be_like %{ "users"."name" != ':\\'(' }
end end
end end
it "should visit_Class" do it "should visit_Class" do
compile(Nodes.build_quoted(DateTime)).must_equal "'DateTime'" _(compile(Nodes.build_quoted(DateTime))).must_equal "'DateTime'"
end end
it "should escape LIMIT" do it "should escape LIMIT" do
@ -232,30 +232,30 @@ module Arel
test = table[:created_at].eq dt test = table[:created_at].eq dt
sql = compile test sql = compile test
sql.must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d %H:%M:%S")}'} _(sql).must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d %H:%M:%S")}'}
end end
it "should visit_Float" do it "should visit_Float" do
test = Table.new(:products)[:price].eq 2.14 test = Table.new(:products)[:price].eq 2.14
sql = compile test sql = compile test
sql.must_be_like %{"products"."price" = 2.14} _(sql).must_be_like %{"products"."price" = 2.14}
end end
it "should visit_Not" do it "should visit_Not" do
sql = compile Nodes::Not.new(Arel.sql("foo")) sql = compile Nodes::Not.new(Arel.sql("foo"))
sql.must_be_like "NOT (foo)" _(sql).must_be_like "NOT (foo)"
end end
it "should apply Not to the whole expression" do it "should apply Not to the whole expression" do
node = Nodes::And.new [@attr.eq(10), @attr.eq(11)] node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
sql = compile Nodes::Not.new(node) sql = compile Nodes::Not.new(node)
sql.must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)} _(sql).must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)}
end end
it "should visit_As" do it "should visit_As" do
as = Nodes::As.new(Arel.sql("foo"), Arel.sql("bar")) as = Nodes::As.new(Arel.sql("foo"), Arel.sql("bar"))
sql = compile as sql = compile as
sql.must_be_like "foo AS bar" _(sql).must_be_like "foo AS bar"
end end
it "should visit_Integer" do it "should visit_Integer" do
@ -280,11 +280,11 @@ module Arel
test = table[:created_at].eq dt test = table[:created_at].eq dt
sql = compile test sql = compile test
sql.must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d")}'} _(sql).must_be_like %{"users"."created_at" = '#{dt.strftime("%Y-%m-%d")}'}
end end
it "should visit_NilClass" do it "should visit_NilClass" do
compile(Nodes.build_quoted(nil)).must_be_like "NULL" _(compile(Nodes.build_quoted(nil))).must_be_like "NULL"
end end
it "unsupported input should raise UnsupportedVisitError" do it "unsupported input should raise UnsupportedVisitError" do
@ -294,19 +294,19 @@ module Arel
it "should visit_Arel_SelectManager, which is a subquery" do it "should visit_Arel_SelectManager, which is a subquery" do
mgr = Table.new(:foo).project(:bar) mgr = Table.new(:foo).project(:bar)
compile(mgr).must_be_like '(SELECT bar FROM "foo")' _(compile(mgr)).must_be_like '(SELECT bar FROM "foo")'
end end
it "should visit_Arel_Nodes_And" do it "should visit_Arel_Nodes_And" do
node = Nodes::And.new [@attr.eq(10), @attr.eq(11)] node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" = 10 AND "users"."id" = 11 "users"."id" = 10 AND "users"."id" = 11
} }
end end
it "should visit_Arel_Nodes_Or" do it "should visit_Arel_Nodes_Or" do
node = Nodes::Or.new @attr.eq(10), @attr.eq(11) node = Nodes::Or.new @attr.eq(10), @attr.eq(11)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" = 10 OR "users"."id" = 11 "users"."id" = 10 OR "users"."id" = 11
} }
end end
@ -317,7 +317,7 @@ module Arel
Nodes::UnqualifiedColumn.new(column), Nodes::UnqualifiedColumn.new(column),
Nodes::UnqualifiedColumn.new(column) Nodes::UnqualifiedColumn.new(column)
) )
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"id" = "id" "id" = "id"
} }
end end
@ -329,20 +329,20 @@ module Arel
it "should visit_TrueClass" do it "should visit_TrueClass" do
test = Table.new(:users)[:bool].eq(true) test = Table.new(:users)[:bool].eq(true)
compile(test).must_be_like %{ "users"."bool" = 't' } _(compile(test)).must_be_like %{ "users"."bool" = 't' }
end end
describe "Nodes::Matches" do describe "Nodes::Matches" do
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].matches("foo%") node = @table[:name].matches("foo%")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" LIKE 'foo%' "users"."name" LIKE 'foo%'
} }
end end
it "can handle ESCAPE" do it "can handle ESCAPE" do
node = @table[:name].matches("foo!%", "!") node = @table[:name].matches("foo!%", "!")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" LIKE 'foo!%' ESCAPE '!' "users"."name" LIKE 'foo!%' ESCAPE '!'
} }
end end
@ -350,7 +350,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].matches("foo%")) subquery = @table.project(:id).where(@table[:name].matches("foo%"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" LIKE 'foo%') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" LIKE 'foo%')
} }
end end
@ -359,14 +359,14 @@ module Arel
describe "Nodes::DoesNotMatch" do describe "Nodes::DoesNotMatch" do
it "should know how to visit" do it "should know how to visit" do
node = @table[:name].does_not_match("foo%") node = @table[:name].does_not_match("foo%")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" NOT LIKE 'foo%' "users"."name" NOT LIKE 'foo%'
} }
end end
it "can handle ESCAPE" do it "can handle ESCAPE" do
node = @table[:name].does_not_match("foo!%", "!") node = @table[:name].does_not_match("foo!%", "!")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."name" NOT LIKE 'foo!%' ESCAPE '!' "users"."name" NOT LIKE 'foo!%' ESCAPE '!'
} }
end end
@ -374,7 +374,7 @@ module Arel
it "can handle subqueries" do it "can handle subqueries" do
subquery = @table.project(:id).where(@table[:name].does_not_match("foo%")) subquery = @table.project(:id).where(@table[:name].does_not_match("foo%"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT LIKE 'foo%') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" NOT LIKE 'foo%')
} }
end end
@ -383,7 +383,7 @@ module Arel
describe "Nodes::Ordering" do describe "Nodes::Ordering" do
it "should know how to visit" do it "should know how to visit" do
node = @attr.desc node = @attr.desc
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" DESC "users"."id" DESC
} }
end end
@ -392,57 +392,57 @@ module Arel
describe "Nodes::In" do describe "Nodes::In" do
it "should know how to visit" do it "should know how to visit" do
node = @attr.in [1, 2, 3] node = @attr.in [1, 2, 3]
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (1, 2, 3) "users"."id" IN (1, 2, 3)
} }
node = @attr.in [1, 2, 3, 4, 5] node = @attr.in [1, 2, 3, 4, 5]
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
("users"."id" IN (1, 2, 3) OR "users"."id" IN (4, 5)) ("users"."id" IN (1, 2, 3) OR "users"."id" IN (4, 5))
} }
end end
it "should return 1=0 when empty right which is always false" do it "should return 1=0 when empty right which is always false" do
node = @attr.in [] node = @attr.in []
compile(node).must_equal "1=0" _(compile(node)).must_equal "1=0"
end end
it "can handle two dot ranges" do it "can handle two dot ranges" do
node = @attr.between 1..3 node = @attr.between 1..3
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" BETWEEN 1 AND 3 "users"."id" BETWEEN 1 AND 3
} }
end end
it "can handle three dot ranges" do it "can handle three dot ranges" do
node = @attr.between 1...3 node = @attr.between 1...3
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" >= 1 AND "users"."id" < 3 "users"."id" >= 1 AND "users"."id" < 3
} }
end end
it "can handle ranges bounded by infinity" do it "can handle ranges bounded by infinity" do
node = @attr.between 1..Float::INFINITY node = @attr.between 1..Float::INFINITY
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" >= 1 "users"."id" >= 1
} }
node = @attr.between(-Float::INFINITY..3) node = @attr.between(-Float::INFINITY..3)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" <= 3 "users"."id" <= 3
} }
node = @attr.between(-Float::INFINITY...3) node = @attr.between(-Float::INFINITY...3)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" < 3 "users"."id" < 3
} }
node = @attr.between(-Float::INFINITY..Float::INFINITY) node = @attr.between(-Float::INFINITY..Float::INFINITY)
compile(node).must_be_like %{1=1} _(compile(node)).must_be_like %{1=1}
end end
it "can handle subqueries" do it "can handle subqueries" do
table = Table.new(:users) table = Table.new(:users)
subquery = table.project(:id).where(table[:name].eq("Aaron")) subquery = table.project(:id).where(table[:name].eq("Aaron"))
node = @attr.in subquery node = @attr.in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron') "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
} }
end end
@ -451,53 +451,53 @@ module Arel
describe "Nodes::InfixOperation" do describe "Nodes::InfixOperation" do
it "should handle Multiplication" do it "should handle Multiplication" do
node = Arel::Attributes::Decimal.new(Table.new(:products), :price) * Arel::Attributes::Decimal.new(Table.new(:currency_rates), :rate) node = Arel::Attributes::Decimal.new(Table.new(:products), :price) * Arel::Attributes::Decimal.new(Table.new(:currency_rates), :rate)
compile(node).must_equal %("products"."price" * "currency_rates"."rate") _(compile(node)).must_equal %("products"."price" * "currency_rates"."rate")
end end
it "should handle Division" do it "should handle Division" do
node = Arel::Attributes::Decimal.new(Table.new(:products), :price) / 5 node = Arel::Attributes::Decimal.new(Table.new(:products), :price) / 5
compile(node).must_equal %("products"."price" / 5) _(compile(node)).must_equal %("products"."price" / 5)
end end
it "should handle Addition" do it "should handle Addition" do
node = Arel::Attributes::Decimal.new(Table.new(:products), :price) + 6 node = Arel::Attributes::Decimal.new(Table.new(:products), :price) + 6
compile(node).must_equal %(("products"."price" + 6)) _(compile(node)).must_equal %(("products"."price" + 6))
end end
it "should handle Subtraction" do it "should handle Subtraction" do
node = Arel::Attributes::Decimal.new(Table.new(:products), :price) - 7 node = Arel::Attributes::Decimal.new(Table.new(:products), :price) - 7
compile(node).must_equal %(("products"."price" - 7)) _(compile(node)).must_equal %(("products"."price" - 7))
end end
it "should handle Concatenation" do it "should handle Concatenation" do
table = Table.new(:users) table = Table.new(:users)
node = table[:name].concat(table[:name]) node = table[:name].concat(table[:name])
compile(node).must_equal %("users"."name" || "users"."name") _(compile(node)).must_equal %("users"."name" || "users"."name")
end end
it "should handle BitwiseAnd" do it "should handle BitwiseAnd" do
node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) & 16 node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) & 16
compile(node).must_equal %(("products"."bitmap" & 16)) _(compile(node)).must_equal %(("products"."bitmap" & 16))
end end
it "should handle BitwiseOr" do it "should handle BitwiseOr" do
node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) | 16 node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) | 16
compile(node).must_equal %(("products"."bitmap" | 16)) _(compile(node)).must_equal %(("products"."bitmap" | 16))
end end
it "should handle BitwiseXor" do it "should handle BitwiseXor" do
node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) ^ 16 node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) ^ 16
compile(node).must_equal %(("products"."bitmap" ^ 16)) _(compile(node)).must_equal %(("products"."bitmap" ^ 16))
end end
it "should handle BitwiseShiftLeft" do it "should handle BitwiseShiftLeft" do
node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) << 4 node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) << 4
compile(node).must_equal %(("products"."bitmap" << 4)) _(compile(node)).must_equal %(("products"."bitmap" << 4))
end end
it "should handle BitwiseShiftRight" do it "should handle BitwiseShiftRight" do
node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) >> 4 node = Arel::Attributes::Integer.new(Table.new(:products), :bitmap) >> 4
compile(node).must_equal %(("products"."bitmap" >> 4)) _(compile(node)).must_equal %(("products"."bitmap" >> 4))
end end
it "should handle arbitrary operators" do it "should handle arbitrary operators" do
@ -506,19 +506,19 @@ module Arel
Arel::Attributes::String.new(Table.new(:products), :name), Arel::Attributes::String.new(Table.new(:products), :name),
Arel::Attributes::String.new(Table.new(:products), :name) Arel::Attributes::String.new(Table.new(:products), :name)
) )
compile(node).must_equal %("products"."name" && "products"."name") _(compile(node)).must_equal %("products"."name" && "products"."name")
end end
end end
describe "Nodes::UnaryOperation" do describe "Nodes::UnaryOperation" do
it "should handle BitwiseNot" do it "should handle BitwiseNot" do
node = ~ Arel::Attributes::Integer.new(Table.new(:products), :bitmap) node = ~ Arel::Attributes::Integer.new(Table.new(:products), :bitmap)
compile(node).must_equal %( ~ "products"."bitmap") _(compile(node)).must_equal %( ~ "products"."bitmap")
end end
it "should handle arbitrary operators" do it "should handle arbitrary operators" do
node = Arel::Nodes::UnaryOperation.new("!", Arel::Attributes::String.new(Table.new(:products), :active)) node = Arel::Nodes::UnaryOperation.new("!", Arel::Attributes::String.new(Table.new(:products), :active))
compile(node).must_equal %( ! "products"."active") _(compile(node)).must_equal %( ! "products"."active")
end end
end end
@ -547,57 +547,57 @@ module Arel
describe "Nodes::NotIn" do describe "Nodes::NotIn" do
it "should know how to visit" do it "should know how to visit" do
node = @attr.not_in [1, 2, 3] node = @attr.not_in [1, 2, 3]
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" NOT IN (1, 2, 3) "users"."id" NOT IN (1, 2, 3)
} }
node = @attr.not_in [1, 2, 3, 4, 5] node = @attr.not_in [1, 2, 3, 4, 5]
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" NOT IN (1, 2, 3) AND "users"."id" NOT IN (4, 5) "users"."id" NOT IN (1, 2, 3) AND "users"."id" NOT IN (4, 5)
} }
end end
it "should return 1=1 when empty right which is always true" do it "should return 1=1 when empty right which is always true" do
node = @attr.not_in [] node = @attr.not_in []
compile(node).must_equal "1=1" _(compile(node)).must_equal "1=1"
end end
it "can handle two dot ranges" do it "can handle two dot ranges" do
node = @attr.not_between 1..3 node = @attr.not_between 1..3
compile(node).must_equal( _(compile(node)).must_equal(
%{("users"."id" < 1 OR "users"."id" > 3)} %{("users"."id" < 1 OR "users"."id" > 3)}
) )
end end
it "can handle three dot ranges" do it "can handle three dot ranges" do
node = @attr.not_between 1...3 node = @attr.not_between 1...3
compile(node).must_equal( _(compile(node)).must_equal(
%{("users"."id" < 1 OR "users"."id" >= 3)} %{("users"."id" < 1 OR "users"."id" >= 3)}
) )
end end
it "can handle ranges bounded by infinity" do it "can handle ranges bounded by infinity" do
node = @attr.not_between 1..Float::INFINITY node = @attr.not_between 1..Float::INFINITY
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" < 1 "users"."id" < 1
} }
node = @attr.not_between(-Float::INFINITY..3) node = @attr.not_between(-Float::INFINITY..3)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" > 3 "users"."id" > 3
} }
node = @attr.not_between(-Float::INFINITY...3) node = @attr.not_between(-Float::INFINITY...3)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" >= 3 "users"."id" >= 3
} }
node = @attr.not_between(-Float::INFINITY..Float::INFINITY) node = @attr.not_between(-Float::INFINITY..Float::INFINITY)
compile(node).must_be_like %{1=0} _(compile(node)).must_be_like %{1=0}
end end
it "can handle subqueries" do it "can handle subqueries" do
table = Table.new(:users) table = Table.new(:users)
subquery = table.project(:id).where(table[:name].eq("Aaron")) subquery = table.project(:id).where(table[:name].eq("Aaron"))
node = @attr.not_in subquery node = @attr.not_in subquery
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
"users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron') "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
} }
end end
@ -606,14 +606,14 @@ module Arel
describe "Constants" do describe "Constants" do
it "should handle true" do it "should handle true" do
test = Table.new(:users).create_true test = Table.new(:users).create_true
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
TRUE TRUE
} }
end end
it "should handle false" do it "should handle false" do
test = Table.new(:users).create_false test = Table.new(:users).create_false
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
FALSE FALSE
} }
end end
@ -622,7 +622,7 @@ module Arel
describe "TableAlias" do describe "TableAlias" do
it "should use the underlying table for checking columns" do it "should use the underlying table for checking columns" do
test = Table.new(:users).alias("zomgusers")[:id].eq "3" test = Table.new(:users).alias("zomgusers")[:id].eq "3"
compile(test).must_be_like %{ _(compile(test)).must_be_like %{
"zomgusers"."id" = '3' "zomgusers"."id" = '3'
} }
end end
@ -665,7 +665,7 @@ module Arel
.when("foo").then(1) .when("foo").then(1)
.else(0) .else(0)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CASE "users"."name" WHEN 'foo' THEN 1 ELSE 0 END CASE "users"."name" WHEN 'foo' THEN 1 ELSE 0 END
} }
end end
@ -675,7 +675,7 @@ module Arel
.when(@table[:name].in(%w(foo bar))).then(1) .when(@table[:name].in(%w(foo bar))).then(1)
.else(0) .else(0)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CASE WHEN "users"."name" IN ('foo', 'bar') THEN 1 ELSE 0 END CASE WHEN "users"."name" IN ('foo', 'bar') THEN 1 ELSE 0 END
} }
end end
@ -684,7 +684,7 @@ module Arel
node = Arel::Nodes::Case.new(@table[:name]) node = Arel::Nodes::Case.new(@table[:name])
.when("foo").then(1) .when("foo").then(1)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CASE "users"."name" WHEN 'foo' THEN 1 END CASE "users"."name" WHEN 'foo' THEN 1 END
} }
end end
@ -695,7 +695,7 @@ module Arel
.when("bar").then(2) .when("bar").then(2)
.else(0) .else(0)
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 2 ELSE 0 END CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 2 ELSE 0 END
} }
end end
@ -705,7 +705,7 @@ module Arel
{ foo: 1, bar: 0 }.reduce(node) { |_node, pair| _node.when(*pair) } { foo: 1, bar: 0 }.reduce(node) { |_node, pair| _node.when(*pair) }
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 0 END CASE "users"."name" WHEN 'foo' THEN 1 WHEN 'bar' THEN 0 END
} }
end end
@ -713,7 +713,7 @@ module Arel
it "can be chained as a predicate" do it "can be chained as a predicate" do
node = @table[:name].when("foo").then("bar").else("baz") node = @table[:name].when("foo").then("bar").else("baz")
compile(node).must_be_like %{ _(compile(node)).must_be_like %{
CASE "users"."name" WHEN 'foo' THEN 'bar' ELSE 'baz' END CASE "users"."name" WHEN 'foo' THEN 'bar' ELSE 'baz' END
} }
end end