2010-10-18 19:54:50 -04:00
|
|
|
require 'helper'
|
2010-08-12 19:19:54 -04:00
|
|
|
|
|
|
|
module Arel
|
2010-08-14 22:48:33 -04:00
|
|
|
class EngineProxy
|
|
|
|
attr_reader :executed
|
2010-09-21 12:20:14 -04:00
|
|
|
attr_reader :connection_pool
|
|
|
|
attr_reader :spec
|
|
|
|
attr_reader :config
|
2010-08-14 22:48:33 -04:00
|
|
|
|
|
|
|
def initialize engine
|
|
|
|
@engine = engine
|
|
|
|
@executed = []
|
2010-09-21 12:20:14 -04:00
|
|
|
@connection_pool = self
|
|
|
|
@spec = self
|
|
|
|
@config = { :adapter => 'sqlite3' }
|
2010-08-14 22:48:33 -04:00
|
|
|
end
|
|
|
|
|
2010-09-24 12:41:48 -04:00
|
|
|
def with_connection
|
|
|
|
yield self
|
|
|
|
end
|
|
|
|
|
2010-08-14 22:48:33 -04:00
|
|
|
def connection
|
|
|
|
self
|
|
|
|
end
|
|
|
|
|
|
|
|
def quote_table_name thing; @engine.connection.quote_table_name thing end
|
|
|
|
def quote_column_name thing; @engine.connection.quote_column_name thing end
|
|
|
|
def quote thing, column; @engine.connection.quote thing, column end
|
2010-12-03 18:24:30 -05:00
|
|
|
def columns table, message = nil
|
|
|
|
@engine.connection.columns table, message
|
|
|
|
end
|
|
|
|
|
2011-02-07 12:26:18 -05:00
|
|
|
def columns_hash
|
|
|
|
@engine.connection.columns_hash
|
|
|
|
end
|
|
|
|
|
2010-12-03 18:24:30 -05:00
|
|
|
def table_exists? name
|
|
|
|
@engine.connection.table_exists? name
|
|
|
|
end
|
2010-08-14 22:48:33 -04:00
|
|
|
|
2010-12-03 19:01:36 -05:00
|
|
|
def tables
|
|
|
|
@engine.connection.tables
|
|
|
|
end
|
|
|
|
|
2010-09-28 19:46:06 -04:00
|
|
|
def execute sql, name = nil, *args
|
2010-08-14 22:48:33 -04:00
|
|
|
@executed << sql
|
|
|
|
end
|
2010-08-23 16:28:08 -04:00
|
|
|
alias :update :execute
|
2010-08-23 16:41:34 -04:00
|
|
|
alias :delete :execute
|
2010-09-09 18:20:25 -04:00
|
|
|
alias :insert :execute
|
2010-08-14 22:48:33 -04:00
|
|
|
end
|
|
|
|
|
2010-08-13 18:30:22 -04:00
|
|
|
describe 'select manager' do
|
2010-12-14 17:56:15 -05:00
|
|
|
def test_join_sources
|
2011-01-21 19:54:58 -05:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.join_sources << Arel::Nodes::StringJoin.new('foo')
|
2011-04-21 16:46:24 -04:00
|
|
|
assert_equal "SELECT FROM 'foo'", manager.to_sql
|
2010-12-14 17:56:15 -05:00
|
|
|
end
|
|
|
|
|
2010-09-10 20:05:10 -04:00
|
|
|
describe 'backwards compatibility' do
|
2010-10-15 18:45:55 -04:00
|
|
|
describe 'project' do
|
|
|
|
it 'accepts symbols as sql literals' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project :id
|
|
|
|
manager.from table
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-10-15 18:45:55 -04:00
|
|
|
SELECT id FROM "users"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-12 22:27:54 -04:00
|
|
|
describe 'order' do
|
|
|
|
it 'accepts symbols' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
manager.from table
|
|
|
|
manager.order :foo
|
2010-11-05 19:33:26 -04:00
|
|
|
manager.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo }
|
2010-09-12 22:27:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-12 21:23:28 -04:00
|
|
|
describe 'group' do
|
|
|
|
it 'takes a symbol' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
|
|
|
manager.group :foo
|
2010-11-05 19:33:26 -04:00
|
|
|
manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo }
|
2010-09-12 21:23:28 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-03-24 14:13:21 -04:00
|
|
|
describe 'as' do
|
|
|
|
it 'makes an AS node by grouping the AST' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
as = manager.as(Arel.sql('foo'))
|
|
|
|
assert_kind_of Arel::Nodes::Grouping, as.left
|
|
|
|
assert_equal manager.ast, as.left.expr
|
|
|
|
assert_equal 'foo', as.right
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'converts right to SqlLiteral if a string' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
as = manager.as('foo')
|
|
|
|
assert_kind_of Arel::Nodes::SqlLiteral, as.right
|
|
|
|
end
|
2011-04-18 12:40:47 -04:00
|
|
|
|
|
|
|
it 'can make a subselect' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project Arel.star
|
|
|
|
manager.from Arel.sql('zomg')
|
|
|
|
as = manager.as(Arel.sql('foo'))
|
|
|
|
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project Arel.sql('name')
|
|
|
|
manager.from as
|
|
|
|
manager.to_sql.must_be_like "SELECT name FROM (SELECT * FROM zomg ) foo"
|
|
|
|
end
|
2011-03-24 14:13:21 -04:00
|
|
|
end
|
|
|
|
|
2010-09-12 19:53:12 -04:00
|
|
|
describe 'from' do
|
|
|
|
it 'ignores strings when table of same name exists' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
|
|
|
|
manager.from table
|
|
|
|
manager.from 'users'
|
|
|
|
manager.project table['id']
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like 'SELECT "users"."id" FROM users'
|
2010-09-12 19:53:12 -04:00
|
|
|
end
|
2011-03-23 20:55:03 -04:00
|
|
|
|
|
|
|
it 'should support any ast' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager1 = Arel::SelectManager.new Table.engine
|
|
|
|
|
|
|
|
manager2 = Arel::SelectManager.new Table.engine
|
|
|
|
manager2.project(Arel.sql('*'))
|
|
|
|
manager2.from table
|
|
|
|
|
|
|
|
manager1.project Arel.sql('lol')
|
2011-03-24 14:13:21 -04:00
|
|
|
as = manager2.as Arel.sql('omg')
|
|
|
|
manager1.from(as)
|
2011-03-23 20:55:03 -04:00
|
|
|
|
|
|
|
manager1.to_sql.must_be_like %{
|
2011-03-30 12:54:23 -04:00
|
|
|
SELECT lol FROM (SELECT * FROM "users" ) omg
|
2011-03-23 20:55:03 -04:00
|
|
|
}
|
|
|
|
end
|
2010-09-12 19:53:12 -04:00
|
|
|
end
|
|
|
|
|
2011-01-03 18:11:34 -05:00
|
|
|
describe 'having' do
|
2010-09-10 20:05:10 -04:00
|
|
|
it 'converts strings to SQLLiterals' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.having 'foo'
|
2010-10-18 18:41:21 -04:00
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo }
|
2010-09-10 20:05:10 -04:00
|
|
|
end
|
2011-01-03 18:11:34 -05:00
|
|
|
|
|
|
|
it 'can have multiple items specified separately' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.having 'foo'
|
|
|
|
mgr.having 'bar'
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'can have multiple items specified together' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.having 'foo', 'bar'
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" HAVING foo AND bar }
|
|
|
|
end
|
2010-09-10 20:05:10 -04:00
|
|
|
end
|
2011-02-21 18:01:49 -05:00
|
|
|
|
|
|
|
describe 'on' do
|
|
|
|
it 'converts to sqlliterals' do
|
|
|
|
table = Table.new :users
|
|
|
|
right = table.alias
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.join(right).on("omg")
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg }
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'converts to sqlliterals' do
|
|
|
|
table = Table.new :users
|
|
|
|
right = table.alias
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.join(right).on("omg", "123")
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" INNER JOIN "users" "users_2" ON omg AND 123 }
|
|
|
|
end
|
|
|
|
end
|
2010-09-10 20:05:10 -04:00
|
|
|
end
|
|
|
|
|
2010-09-14 16:39:33 -04:00
|
|
|
describe 'clone' do
|
|
|
|
it 'creates new cores' do
|
|
|
|
table = Table.new :users, :engine => Table.engine, :as => 'foo'
|
|
|
|
mgr = table.from table
|
|
|
|
m2 = mgr.clone
|
|
|
|
m2.project "foo"
|
2010-10-18 18:41:21 -04:00
|
|
|
mgr.to_sql.wont_equal m2.to_sql
|
2010-09-14 16:39:33 -04:00
|
|
|
end
|
2011-04-15 10:34:18 -04:00
|
|
|
|
|
|
|
it 'makes updates to the correct copy' do
|
|
|
|
table = Table.new :users, :engine => Table.engine, :as => 'foo'
|
|
|
|
mgr = table.from table
|
|
|
|
m2 = mgr.clone
|
|
|
|
m3 = m2.clone
|
|
|
|
m2.project "foo"
|
|
|
|
mgr.to_sql.wont_equal m2.to_sql
|
|
|
|
m3.to_sql.must_equal mgr.to_sql
|
|
|
|
end
|
2010-09-14 16:39:33 -04:00
|
|
|
end
|
|
|
|
|
2010-09-12 21:15:21 -04:00
|
|
|
describe 'initialize' do
|
|
|
|
it 'uses alias in sql' do
|
|
|
|
table = Table.new :users, :engine => Table.engine, :as => 'foo'
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.skip 10
|
2011-05-17 18:01:35 -04:00
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
|
2010-09-12 21:15:21 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-10 12:47:50 -04:00
|
|
|
describe 'skip' do
|
|
|
|
it 'should add an offset' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.skip 10
|
2010-10-18 18:41:21 -04:00
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
|
2010-09-10 12:47:50 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'should chain' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
2010-10-18 18:41:21 -04:00
|
|
|
mgr.skip(10).to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
|
2010-09-10 12:47:50 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-02-25 18:23:21 -05:00
|
|
|
describe 'offset' do
|
|
|
|
it 'should add an offset' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.offset = 10
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should remove an offset' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.offset = 10
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" OFFSET 10 }
|
|
|
|
|
|
|
|
mgr.offset = nil
|
|
|
|
mgr.to_sql.must_be_like %{ SELECT FROM "users" }
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should return the offset' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
mgr.offset = 10
|
|
|
|
assert_equal 10, mgr.offset
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-11-05 19:33:26 -04:00
|
|
|
describe 'exists' do
|
|
|
|
it 'should create an exists clause' do
|
|
|
|
table = Table.new(:users)
|
|
|
|
manager = Arel::SelectManager.new Table.engine, table
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
m2 = Arel::SelectManager.new(manager.engine)
|
|
|
|
m2.project manager.exists
|
|
|
|
m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) }
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'can be aliased' do
|
|
|
|
table = Table.new(:users)
|
|
|
|
manager = Arel::SelectManager.new Table.engine, table
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
m2 = Arel::SelectManager.new(manager.engine)
|
|
|
|
m2.project manager.exists.as('foo')
|
|
|
|
m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) AS foo }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2011-01-20 14:56:08 -05:00
|
|
|
describe 'union' do
|
2011-01-21 19:54:58 -05:00
|
|
|
before do
|
|
|
|
table = Table.new :users
|
|
|
|
@m1 = Arel::SelectManager.new Table.engine, table
|
|
|
|
@m1.project Arel.star
|
|
|
|
@m1.where(table[:age].lt(18))
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
@m2 = Arel::SelectManager.new Table.engine, table
|
|
|
|
@m2.project Arel.star
|
|
|
|
@m2.where(table[:age].gt(99))
|
2011-01-20 14:56:08 -05:00
|
|
|
|
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
end
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
it 'should union two managers' do
|
|
|
|
# FIXME should this union "managers" or "statements" ?
|
|
|
|
# FIXME this probably shouldn't return a node
|
|
|
|
node = @m1.union @m2
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
# maybe FIXME: decide when wrapper parens are needed
|
|
|
|
node.to_sql.must_be_like %{
|
|
|
|
( SELECT * FROM "users" WHERE "users"."age" < 18 UNION SELECT * FROM "users" WHERE "users"."age" > 99 )
|
|
|
|
}
|
|
|
|
end
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
it 'should union all' do
|
|
|
|
node = @m1.union :all, @m2
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
node.to_sql.must_be_like %{
|
|
|
|
( SELECT * FROM "users" WHERE "users"."age" < 18 UNION ALL SELECT * FROM "users" WHERE "users"."age" > 99 )
|
|
|
|
}
|
|
|
|
end
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
end
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-22 09:16:53 -05:00
|
|
|
describe 'intersect' do
|
|
|
|
before do
|
|
|
|
table = Table.new :users
|
|
|
|
@m1 = Arel::SelectManager.new Table.engine, table
|
|
|
|
@m1.project Arel.star
|
|
|
|
@m1.where(table[:age].gt(18))
|
|
|
|
|
|
|
|
@m2 = Arel::SelectManager.new Table.engine, table
|
|
|
|
@m2.project Arel.star
|
|
|
|
@m2.where(table[:age].lt(99))
|
|
|
|
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should interect two managers' do
|
|
|
|
# FIXME should this intersect "managers" or "statements" ?
|
|
|
|
# FIXME this probably shouldn't return a node
|
|
|
|
node = @m1.intersect @m2
|
|
|
|
|
|
|
|
# maybe FIXME: decide when wrapper parens are needed
|
|
|
|
node.to_sql.must_be_like %{
|
|
|
|
( SELECT * FROM "users" WHERE "users"."age" > 18 INTERSECT SELECT * FROM "users" WHERE "users"."age" < 99 )
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'except' do
|
|
|
|
before do
|
|
|
|
table = Table.new :users
|
|
|
|
@m1 = Arel::SelectManager.new Table.engine, table
|
|
|
|
@m1.project Arel.star
|
|
|
|
@m1.where(table[:age].in(18..60))
|
|
|
|
|
|
|
|
@m2 = Arel::SelectManager.new Table.engine, table
|
|
|
|
@m2.project Arel.star
|
|
|
|
@m2.where(table[:age].in(40..99))
|
|
|
|
|
|
|
|
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should except two managers' do
|
|
|
|
# FIXME should this except "managers" or "statements" ?
|
|
|
|
# FIXME this probably shouldn't return a node
|
|
|
|
node = @m1.except @m2
|
|
|
|
|
|
|
|
# maybe FIXME: decide when wrapper parens are needed
|
|
|
|
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 )
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
end
|
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
describe 'with' do
|
2011-01-20 14:56:08 -05:00
|
|
|
|
|
|
|
it "should support WITH RECURSIVE" do
|
|
|
|
comments = Table.new(:comments)
|
|
|
|
comments_id = comments[:id]
|
|
|
|
comments_parent_id = comments[:parent_id]
|
|
|
|
|
|
|
|
replies = Table.new(:replies)
|
|
|
|
replies_id = replies[:id]
|
|
|
|
|
|
|
|
recursive_term = Arel::SelectManager.new Table.engine
|
|
|
|
recursive_term.from(comments).project(comments_id, comments_parent_id).where(comments_id.eq 42)
|
|
|
|
|
|
|
|
non_recursive_term = Arel::SelectManager.new Table.engine
|
|
|
|
non_recursive_term.from(comments).project(comments_id, comments_parent_id).join(replies).on(comments_parent_id.eq replies_id)
|
|
|
|
|
|
|
|
union = recursive_term.union(non_recursive_term)
|
|
|
|
|
|
|
|
as_statement = Arel::Nodes::As.new replies, union
|
|
|
|
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2011-01-25 13:27:42 -05:00
|
|
|
manager.with(:recursive, as_statement).from(replies).project(Arel.star)
|
2011-01-20 14:56:08 -05:00
|
|
|
|
|
|
|
sql = manager.to_sql
|
|
|
|
sql.must_be_like %{
|
|
|
|
WITH RECURSIVE "replies" AS (
|
|
|
|
SELECT "comments"."id", "comments"."parent_id" FROM "comments" WHERE "comments"."id" = 42
|
|
|
|
UNION
|
|
|
|
SELECT "comments"."id", "comments"."parent_id" FROM "comments" INNER JOIN "replies" ON "comments"."parent_id" = "replies"."id"
|
|
|
|
)
|
|
|
|
SELECT * FROM "replies"
|
|
|
|
}
|
|
|
|
end
|
2011-01-21 19:54:58 -05:00
|
|
|
end
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2010-11-05 17:09:09 -04:00
|
|
|
describe 'ast' do
|
|
|
|
it 'should return the ast' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
|
|
|
ast = mgr.ast
|
|
|
|
mgr.visitor.accept(ast).must_equal mgr.to_sql
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-09 18:58:06 -04:00
|
|
|
describe 'taken' do
|
|
|
|
it 'should return limit' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.take 10
|
2010-10-18 19:36:49 -04:00
|
|
|
manager.taken.must_equal 10
|
2010-09-09 18:58:06 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-09 18:20:25 -04:00
|
|
|
describe 'insert' do
|
|
|
|
it 'uses the select FROM' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
|
|
|
manager.insert 'VALUES(NULL)'
|
|
|
|
|
2010-10-18 18:41:21 -04:00
|
|
|
engine.executed.last.must_be_like %{
|
2010-09-09 18:20:25 -04:00
|
|
|
INSERT INTO "users" VALUES(NULL)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-08 20:32:44 -04:00
|
|
|
describe 'lock' do
|
|
|
|
# This should fail on other databases
|
|
|
|
it 'adds a lock node' do
|
|
|
|
table = Table.new :users
|
|
|
|
mgr = table.from table
|
2010-10-18 18:41:21 -04:00
|
|
|
mgr.lock.to_sql.must_be_like %{ SELECT FROM "users" }
|
2010-09-08 20:32:44 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-10 13:45:05 -04:00
|
|
|
describe 'orders' do
|
|
|
|
it 'returns order clauses' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
order = table[:id]
|
|
|
|
manager.order table[:id]
|
2010-10-18 19:36:49 -04:00
|
|
|
manager.orders.must_equal [order]
|
2010-09-10 13:45:05 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-22 21:13:39 -04:00
|
|
|
describe 'order' do
|
|
|
|
it 'generates order clauses' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
manager.from table
|
|
|
|
manager.order table[:id]
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-08-22 21:13:39 -04:00
|
|
|
SELECT * FROM "users" ORDER BY "users"."id"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
# FIXME: I would like to deprecate this
|
|
|
|
it 'takes *args' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
manager.from table
|
|
|
|
manager.order table[:id], table[:name]
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-08-22 21:13:39 -04:00
|
|
|
SELECT * FROM "users" ORDER BY "users"."id", "users"."name"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'chains' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-10-18 19:36:49 -04:00
|
|
|
manager.order(table[:id]).must_equal manager
|
2010-08-22 21:13:39 -04:00
|
|
|
end
|
2011-04-28 04:11:50 -04:00
|
|
|
|
|
|
|
it 'has order attributes' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
manager.from table
|
|
|
|
manager.order table[:id].desc
|
|
|
|
manager.to_sql.must_be_like %{
|
|
|
|
SELECT * FROM "users" ORDER BY "users"."id" DESC
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'has order attributes for expressions' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project SqlLiteral.new '*'
|
|
|
|
manager.from table
|
|
|
|
manager.order table[:id].count.desc
|
|
|
|
manager.to_sql.must_be_like %{
|
|
|
|
SELECT * FROM "users" ORDER BY COUNT("users"."id") DESC
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2010-08-22 21:13:39 -04:00
|
|
|
end
|
|
|
|
|
2010-09-07 20:42:40 -04:00
|
|
|
describe 'on' do
|
|
|
|
it 'takes two params' do
|
|
|
|
left = Table.new :users
|
|
|
|
right = left.alias
|
|
|
|
predicate = left[:id].eq(right[:id])
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
|
|
|
|
manager.from left
|
|
|
|
manager.join(right).on(predicate, predicate)
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-09-07 20:42:40 -04:00
|
|
|
SELECT FROM "users"
|
|
|
|
INNER JOIN "users" "users_2"
|
|
|
|
ON "users"."id" = "users_2"."id" AND
|
|
|
|
"users"."id" = "users_2"."id"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'takes three params' do
|
|
|
|
left = Table.new :users
|
|
|
|
right = left.alias
|
|
|
|
predicate = left[:id].eq(right[:id])
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
|
|
|
|
manager.from left
|
|
|
|
manager.join(right).on(
|
|
|
|
predicate,
|
|
|
|
predicate,
|
|
|
|
left[:name].eq(right[:name])
|
|
|
|
)
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-09-07 20:42:40 -04:00
|
|
|
SELECT FROM "users"
|
|
|
|
INNER JOIN "users" "users_2"
|
|
|
|
ON "users"."id" = "users_2"."id" AND
|
|
|
|
"users"."id" = "users_2"."id" AND
|
|
|
|
"users"."name" = "users_2"."name"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-12-07 18:05:51 -05:00
|
|
|
it 'should hand back froms' do
|
|
|
|
relation = Arel::SelectManager.new Table.engine
|
|
|
|
assert_equal [], relation.froms
|
|
|
|
end
|
|
|
|
|
2010-12-09 18:42:29 -05:00
|
|
|
it 'should create and nodes' do
|
|
|
|
relation = Arel::SelectManager.new Table.engine
|
|
|
|
children = ['foo', 'bar', 'baz']
|
|
|
|
clause = relation.create_and children
|
|
|
|
assert_kind_of Arel::Nodes::And, clause
|
|
|
|
assert_equal children, clause.children
|
|
|
|
end
|
|
|
|
|
2011-03-22 00:23:48 -04:00
|
|
|
it 'should create insert managers' do
|
|
|
|
relation = Arel::SelectManager.new Table.engine
|
|
|
|
insert = relation.create_insert
|
|
|
|
assert_kind_of Arel::InsertManager, insert
|
|
|
|
end
|
|
|
|
|
2010-12-07 14:44:32 -05:00
|
|
|
it 'should create join nodes' do
|
|
|
|
relation = Arel::SelectManager.new Table.engine
|
2010-12-14 12:43:19 -05:00
|
|
|
join = relation.create_join 'foo', 'bar'
|
2010-12-07 14:44:32 -05:00
|
|
|
assert_kind_of Arel::Nodes::InnerJoin, join
|
|
|
|
assert_equal 'foo', join.left
|
|
|
|
assert_equal 'bar', join.right
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'should create join nodes with a klass' do
|
|
|
|
relation = Arel::SelectManager.new Table.engine
|
2010-12-14 12:43:19 -05:00
|
|
|
join = relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
|
2010-12-07 14:44:32 -05:00
|
|
|
assert_kind_of Arel::Nodes::OuterJoin, join
|
|
|
|
assert_equal 'foo', join.left
|
|
|
|
assert_equal 'bar', join.right
|
|
|
|
end
|
|
|
|
|
2010-09-07 17:49:37 -04:00
|
|
|
describe 'join' do
|
|
|
|
it 'responds to join' do
|
|
|
|
left = Table.new :users
|
|
|
|
right = left.alias
|
|
|
|
predicate = left[:id].eq(right[:id])
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
|
2010-09-07 18:10:27 -04:00
|
|
|
manager.from left
|
2010-09-07 17:49:37 -04:00
|
|
|
manager.join(right).on(predicate)
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-09-07 18:10:27 -04:00
|
|
|
SELECT FROM "users"
|
|
|
|
INNER JOIN "users" "users_2"
|
|
|
|
ON "users"."id" = "users_2"."id"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'takes a class' do
|
|
|
|
left = Table.new :users
|
|
|
|
right = left.alias
|
|
|
|
predicate = left[:id].eq(right[:id])
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
|
|
|
|
manager.from left
|
|
|
|
manager.join(right, Nodes::OuterJoin).on(predicate)
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-09-07 17:49:37 -04:00
|
|
|
SELECT FROM "users"
|
2010-09-07 18:26:21 -04:00
|
|
|
LEFT OUTER JOIN "users" "users_2"
|
2010-09-07 17:49:37 -04:00
|
|
|
ON "users"."id" = "users_2"."id"
|
|
|
|
}
|
|
|
|
end
|
2010-09-07 18:27:08 -04:00
|
|
|
|
|
|
|
it 'noops on nil' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-10-18 19:36:49 -04:00
|
|
|
manager.join(nil).must_equal manager
|
2010-09-07 18:27:08 -04:00
|
|
|
end
|
2010-09-07 17:49:37 -04:00
|
|
|
end
|
|
|
|
|
2010-08-19 13:37:50 -04:00
|
|
|
describe 'joins' do
|
|
|
|
it 'returns join sql' do
|
|
|
|
table = Table.new :users
|
|
|
|
aliaz = table.alias
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-12-14 12:43:19 -05:00
|
|
|
manager.from Nodes::InnerJoin.new(aliaz, table[:id].eq(aliaz[:id]))
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.join_sql.must_be_like %{
|
2010-08-24 20:59:03 -04:00
|
|
|
INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"
|
2010-08-19 13:37:50 -04:00
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns outer join sql' do
|
|
|
|
table = Table.new :users
|
|
|
|
aliaz = table.alias
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-12-14 12:43:19 -05:00
|
|
|
manager.from Nodes::OuterJoin.new(aliaz, table[:id].eq(aliaz[:id]))
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.join_sql.must_be_like %{
|
2010-09-12 22:22:19 -04:00
|
|
|
LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"
|
2010-08-19 13:37:50 -04:00
|
|
|
}
|
|
|
|
end
|
2010-09-12 18:45:59 -04:00
|
|
|
|
|
|
|
it 'returns string join sql' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-12-14 14:04:08 -05:00
|
|
|
manager.from Nodes::StringJoin.new('hello')
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.join_sql.must_be_like %{ 'hello' }
|
2010-09-12 18:45:59 -04:00
|
|
|
end
|
2010-09-28 19:57:33 -04:00
|
|
|
|
|
|
|
it 'returns nil join sql' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.join_sql.must_be_nil
|
2010-09-28 19:57:33 -04:00
|
|
|
end
|
2010-08-19 13:37:50 -04:00
|
|
|
end
|
|
|
|
|
2010-08-24 21:36:59 -04:00
|
|
|
describe 'order_clauses' do
|
|
|
|
it 'returns order clauses as a list' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
|
|
|
manager.order table[:id]
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.order_clauses.first.must_be_like %{ "users"."id" }
|
2010-08-24 21:36:59 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-07 18:47:38 -04:00
|
|
|
describe 'group' do
|
|
|
|
it 'takes an attribute' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
|
|
|
manager.group table[:id]
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-09-07 18:47:38 -04:00
|
|
|
SELECT FROM "users" GROUP BY "users"."id"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'chains' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-10-18 19:36:49 -04:00
|
|
|
manager.group(table[:id]).must_equal manager
|
2010-09-07 18:47:38 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'takes multiple args' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
|
|
|
manager.group table[:id], table[:name]
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-09-07 18:47:38 -04:00
|
|
|
SELECT FROM "users" GROUP BY "users"."id", "users"."name"
|
|
|
|
}
|
|
|
|
end
|
2010-09-07 19:09:58 -04:00
|
|
|
|
|
|
|
# FIXME: backwards compat
|
|
|
|
it 'makes strings literals' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
|
|
|
manager.group 'foo'
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{ SELECT FROM "users" GROUP BY foo }
|
2010-09-07 19:09:58 -04:00
|
|
|
end
|
2010-09-07 18:47:38 -04:00
|
|
|
end
|
|
|
|
|
2010-08-18 14:32:44 -04:00
|
|
|
describe 'delete' do
|
|
|
|
it "copies from" do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
2010-12-02 18:45:00 -05:00
|
|
|
stmt = manager.compile_delete
|
2010-08-18 14:32:44 -04:00
|
|
|
|
2010-12-02 18:45:00 -05:00
|
|
|
stmt.to_sql.must_be_like %{ DELETE FROM "users" }
|
2010-08-18 14:32:44 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "copies where" do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
|
|
|
manager.where table[:id].eq 10
|
2010-12-02 18:45:00 -05:00
|
|
|
stmt = manager.compile_delete
|
2010-08-18 14:32:44 -04:00
|
|
|
|
2010-12-02 18:45:00 -05:00
|
|
|
stmt.to_sql.must_be_like %{
|
2010-08-18 14:32:44 -04:00
|
|
|
DELETE FROM "users" WHERE "users"."id" = 10
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-10-12 17:17:26 -04:00
|
|
|
describe 'where_sql' do
|
|
|
|
it 'gives me back the where sql' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
|
|
|
manager.where table[:id].eq 10
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.where_sql.must_be_like %{ WHERE "users"."id" = 10 }
|
2010-10-12 17:17:26 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns nil when there are no wheres' do
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.from table
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.where_sql.must_be_nil
|
2010-10-12 17:17:26 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-14 22:48:33 -04:00
|
|
|
describe 'update' do
|
2010-09-14 16:39:33 -04:00
|
|
|
it 'copies limits' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
|
|
|
manager.take 1
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt = manager.compile_update(SqlLiteral.new('foo = bar'))
|
2010-12-24 17:48:33 -05:00
|
|
|
stmt.key = table['id']
|
2010-09-14 16:39:33 -04:00
|
|
|
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt.to_sql.must_be_like %{
|
2010-09-14 16:39:33 -04:00
|
|
|
UPDATE "users" SET foo = bar
|
|
|
|
WHERE "users"."id" IN (SELECT "users"."id" FROM "users" LIMIT 1)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'copies order' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
|
|
|
manager.order :foo
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt = manager.compile_update(SqlLiteral.new('foo = bar'))
|
2010-12-24 17:48:33 -05:00
|
|
|
stmt.key = table['id']
|
2010-09-14 16:39:33 -04:00
|
|
|
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt.to_sql.must_be_like %{
|
2010-09-14 16:39:33 -04:00
|
|
|
UPDATE "users" SET foo = bar
|
|
|
|
WHERE "users"."id" IN (SELECT "users"."id" FROM "users" ORDER BY foo)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2010-08-18 12:52:16 -04:00
|
|
|
it 'takes a string' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt = manager.compile_update(SqlLiteral.new('foo = bar'))
|
2010-08-18 12:52:16 -04:00
|
|
|
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
|
2010-08-18 12:52:16 -04:00
|
|
|
end
|
|
|
|
|
2010-08-14 22:48:33 -04:00
|
|
|
it 'copies where clauses' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.where table[:id].eq 10
|
|
|
|
manager.from table
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt = manager.compile_update(table[:id] => 1)
|
2010-08-14 22:48:33 -04:00
|
|
|
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt.to_sql.must_be_like %{
|
2010-08-14 22:48:33 -04:00
|
|
|
UPDATE "users" SET "id" = 1 WHERE "users"."id" = 10
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2011-03-06 05:28:46 -05:00
|
|
|
it 'copies where clauses when nesting is triggered' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.where table[:foo].eq 10
|
|
|
|
manager.take 42
|
|
|
|
manager.from table
|
|
|
|
stmt = manager.compile_update(table[:id] => 1)
|
|
|
|
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2010-08-14 22:48:33 -04:00
|
|
|
it 'executes an update statement' do
|
|
|
|
engine = EngineProxy.new Table.engine
|
|
|
|
table = Table.new :users
|
|
|
|
manager = Arel::SelectManager.new engine
|
|
|
|
manager.from table
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt = manager.compile_update(table[:id] => 1)
|
2010-08-14 22:48:33 -04:00
|
|
|
|
2010-12-02 17:31:37 -05:00
|
|
|
stmt.to_sql.must_be_like %{
|
2010-08-14 22:48:33 -04:00
|
|
|
UPDATE "users" SET "id" = 1
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-13 11:11:08 -04:00
|
|
|
describe 'project' do
|
2010-08-23 17:59:53 -04:00
|
|
|
it 'takes multiple args' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.project Nodes::SqlLiteral.new('foo'),
|
|
|
|
Nodes::SqlLiteral.new('bar')
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{ SELECT foo, bar }
|
2010-08-23 17:59:53 -04:00
|
|
|
end
|
|
|
|
|
2010-08-13 11:11:08 -04:00
|
|
|
it 'takes strings' do
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-08-18 19:32:32 -04:00
|
|
|
manager.project Nodes::SqlLiteral.new('*')
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{ SELECT * }
|
2010-08-13 11:11:08 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "takes sql literals" do
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-08-13 11:11:08 -04:00
|
|
|
manager.project Nodes::SqlLiteral.new '*'
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-08-13 11:11:08 -04:00
|
|
|
SELECT *
|
2010-08-13 18:30:22 -04:00
|
|
|
}
|
2010-08-13 11:11:08 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-13 00:21:20 -04:00
|
|
|
describe 'take' do
|
|
|
|
it "knows take" do
|
|
|
|
table = Table.new :users
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-08-13 00:21:20 -04:00
|
|
|
manager.from(table).project(table['id'])
|
|
|
|
manager.where(table['id'].eq(1))
|
|
|
|
manager.take 1
|
|
|
|
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-08-13 00:21:20 -04:00
|
|
|
SELECT "users"."id"
|
|
|
|
FROM "users"
|
|
|
|
WHERE "users"."id" = 1
|
|
|
|
LIMIT 1
|
2010-08-13 18:30:22 -04:00
|
|
|
}
|
2010-08-13 00:21:20 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "chains" do
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.take(1).must_equal manager
|
2010-08-13 00:21:20 -04:00
|
|
|
end
|
2011-02-25 18:19:11 -05:00
|
|
|
|
|
|
|
it 'removes LIMIT when nil is passed' do
|
|
|
|
manager = Arel::SelectManager.new Table.engine
|
|
|
|
manager.limit = 10
|
|
|
|
assert_match('LIMIT', manager.to_sql)
|
|
|
|
|
|
|
|
manager.limit = nil
|
|
|
|
refute_match('LIMIT', manager.to_sql)
|
|
|
|
end
|
2010-08-13 00:21:20 -04:00
|
|
|
end
|
|
|
|
|
2010-08-12 19:19:54 -04:00
|
|
|
describe 'where' do
|
|
|
|
it "knows where" do
|
|
|
|
table = Table.new :users
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-08-12 19:19:54 -04:00
|
|
|
manager.from(table).project(table['id'])
|
|
|
|
manager.where(table['id'].eq(1))
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like %{
|
2010-08-12 19:19:54 -04:00
|
|
|
SELECT "users"."id"
|
|
|
|
FROM "users"
|
|
|
|
WHERE "users"."id" = 1
|
2010-08-13 18:30:22 -04:00
|
|
|
}
|
2010-08-12 19:19:54 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "chains" do
|
|
|
|
table = Table.new :users
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-08-12 19:19:54 -04:00
|
|
|
manager.from(table)
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.project(table['id']).where(table['id'].eq 1).must_equal manager
|
2010-08-12 19:19:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-18 19:32:32 -04:00
|
|
|
describe "join" do
|
|
|
|
it "joins itself" do
|
|
|
|
left = Table.new :users
|
|
|
|
right = left.alias
|
|
|
|
predicate = left[:id].eq(right[:id])
|
|
|
|
|
|
|
|
mgr = left.join(right)
|
|
|
|
mgr.project Nodes::SqlLiteral.new('*')
|
2010-10-18 19:36:49 -04:00
|
|
|
mgr.on(predicate).must_equal mgr
|
2010-08-18 19:32:32 -04:00
|
|
|
|
2010-10-18 18:41:21 -04:00
|
|
|
mgr.to_sql.must_be_like %{
|
2010-08-18 19:32:32 -04:00
|
|
|
SELECT * FROM "users"
|
|
|
|
INNER JOIN "users" "users_2"
|
|
|
|
ON "users"."id" = "users_2"."id"
|
|
|
|
}
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-12 19:19:54 -04:00
|
|
|
describe 'from' do
|
|
|
|
it "makes sql" do
|
|
|
|
table = Table.new :users
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-08-12 19:19:54 -04:00
|
|
|
|
|
|
|
manager.from table
|
|
|
|
manager.project table['id']
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"'
|
2010-08-12 19:19:54 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
it "chains" do
|
|
|
|
table = Table.new :users
|
2010-08-13 18:30:22 -04:00
|
|
|
manager = Arel::SelectManager.new Table.engine
|
2010-10-18 19:36:49 -04:00
|
|
|
manager.from(table).project(table['id']).must_equal manager
|
2010-10-18 18:41:21 -04:00
|
|
|
manager.to_sql.must_be_like 'SELECT "users"."id" FROM "users"'
|
2010-08-12 19:19:54 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|