arel 5.0.1.20140414130214 → 6.0.0.beta1

data/test/test_select_manager.rb

@@ -5,7 +5,7 @@ module Arel
   describe 'select manager' do
     def test_join_sources
       manager = Arel::SelectManager.new Table.engine
-      manager.join_sources << Arel::Nodes::StringJoin.new('foo')
+      manager.join_sources << Arel::Nodes::StringJoin.new(Nodes.build_quoted('foo'))
       assert_equal "SELECT FROM 'foo'", manager.to_sql
     end
 
@@ -33,7 +33,7 @@ module Arel
         it 'accepts symbols' do
           table   = Table.new :users
           manager = Arel::SelectManager.new Table.engine
-          manager.project SqlLiteral.new '*'
+          manager.project Nodes::SqlLiteral.new '*'
           manager.from table
           manager.order :foo
           manager.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo }
@@ -140,7 +140,7 @@ module Arel
           mgr.to_sql.must_be_like %{ SELECT  FROM "users" INNER JOIN "users" "users_2" ON omg }
         end
 
-        it 'converts to sqlliterals' do
+        it 'converts to sqlliterals with multiple items' do
           table = Table.new :users
           right = table.alias
           mgr   = table.from table
@@ -152,7 +152,7 @@ module Arel
 
     describe 'clone' do
       it 'creates new cores' do
-        table   = Table.new :users, :engine => Table.engine, :as => 'foo'
+        table   = Table.new :users, :as => 'foo'
         mgr = table.from table
         m2 = mgr.clone
         m2.project "foo"
@@ -160,7 +160,7 @@ module Arel
       end
 
       it 'makes updates to the correct copy' do
-        table   = Table.new :users, :engine => Table.engine, :as => 'foo'
+        table   = Table.new :users, :as => 'foo'
         mgr = table.from table
         m2 = mgr.clone
         m3 = m2.clone
@@ -172,7 +172,7 @@ module Arel
 
     describe 'initialize' do
       it 'uses alias in sql' do
-        table   = Table.new :users, :engine => Table.engine, :as => 'foo'
+        table   = Table.new :users, :as => 'foo'
         mgr = table.from table
         mgr.skip 10
         mgr.to_sql.must_be_like %{ SELECT FROM "users" "foo" OFFSET 10 }
@@ -224,7 +224,7 @@ module Arel
       it 'should create an exists clause' do
         table = Table.new(:users)
         manager = Arel::SelectManager.new Table.engine, table
-        manager.project SqlLiteral.new '*'
+        manager.project Nodes::SqlLiteral.new '*'
         m2 = Arel::SelectManager.new(manager.engine)
         m2.project manager.exists
         m2.to_sql.must_be_like %{ SELECT EXISTS (#{manager.to_sql}) }
@@ -233,7 +233,7 @@ module Arel
       it 'can be aliased' do
         table = Table.new(:users)
         manager = Arel::SelectManager.new Table.engine, table
-        manager.project SqlLiteral.new '*'
+        manager.project Nodes::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 }
@@ -330,6 +330,20 @@ module Arel
     end
 
     describe 'with' do
+      it 'should support basic WITH' do
+        users          = Table.new(:users)
+        users_top      = Table.new(:users_top)
+        comments       = Table.new(:comments)
+
+        top            = users.project(users[:id]).where(users[:karma].gt(100))
+        users_as       = Arel::Nodes::As.new(users_top, top)
+        select_manager = comments.project(Arel.star).with(users_as)
+                          .where(comments[:author_id].in(users_top.project(users_top[:id])))
+
+        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")
+        }
+      end
 
       it "should support WITH RECURSIVE" do
         comments           = Table.new(:comments)
@@ -368,9 +382,9 @@ module Arel
       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
+        assert mgr.ast
       end
+
       it 'should allow orders to work when the ast is grepped' do
         table   = Table.new :users
         mgr = table.from table
@@ -413,7 +427,7 @@ module Arel
       it 'generates order clauses' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        manager.project SqlLiteral.new '*'
+        manager.project Nodes::SqlLiteral.new '*'
         manager.from table
         manager.order table[:id]
         manager.to_sql.must_be_like %{
@@ -425,7 +439,7 @@ module Arel
       it 'takes *args' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        manager.project SqlLiteral.new '*'
+        manager.project Nodes::SqlLiteral.new '*'
         manager.from table
         manager.order table[:id], table[:name]
         manager.to_sql.must_be_like %{
@@ -442,25 +456,13 @@ module Arel
       it 'has order attributes' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
-        manager.project SqlLiteral.new '*'
+        manager.project Nodes::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
-
     end
 
     describe 'on' do
@@ -529,7 +531,15 @@ module Arel
       assert_equal 'bar', join.right
     end
 
-    it 'should create join nodes with a klass' do
+    it 'should create join nodes with a full outer join klass' do
+      relation = Arel::SelectManager.new Table.engine
+      join = relation.create_join 'foo', 'bar', Arel::Nodes::FullOuterJoin
+      assert_kind_of Arel::Nodes::FullOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should create join nodes with a outer join klass' do
       relation = Arel::SelectManager.new Table.engine
       join = relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
       assert_kind_of Arel::Nodes::OuterJoin, join
@@ -537,6 +547,14 @@ module Arel
       assert_equal 'bar', join.right
     end
 
+    it 'should create join nodes with a right outer join klass' do
+      relation = Arel::SelectManager.new Table.engine
+      join = relation.create_join 'foo', 'bar', Arel::Nodes::RightOuterJoin
+      assert_kind_of Arel::Nodes::RightOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
     describe 'join' do
       it 'responds to join' do
         left      = Table.new :users
@@ -574,15 +592,37 @@ module Arel
       end
     end
 
+    describe 'outer 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
+
+        manager.from left
+        manager.outer_join(right).on(predicate)
+        manager.to_sql.must_be_like %{
+           SELECT FROM "users"
+             LEFT OUTER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
+      end
+
+      it 'noops on nil' do
+        manager   = Arel::SelectManager.new Table.engine
+        manager.outer_join(nil).must_equal manager
+      end
+    end
+
     describe 'joins' do
-      it 'returns join sql' do
+
+      it 'returns inner join sql' do
         table   = Table.new :users
         aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
         manager.from Nodes::InnerJoin.new(aliaz, table[:id].eq(aliaz[:id]))
-        manager.join_sql.must_be_like %{
-          INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"
-        }
+        assert_match 'INNER JOIN "users" "users_2" "users"."id" = "users_2"."id"',
+                     manager.to_sql
       end
 
       it 'returns outer join sql' do
@@ -590,9 +630,8 @@ module Arel
         aliaz   = table.alias
         manager = Arel::SelectManager.new Table.engine
         manager.from Nodes::OuterJoin.new(aliaz, table[:id].eq(aliaz[:id]))
-        manager.join_sql.must_be_like %{
-          LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"
-        }
+        assert_match 'LEFT OUTER JOIN "users" "users_2" "users"."id" = "users_2"."id"',
+                     manager.to_sql
       end
 
       it 'can have a non-table alias as relation name' do
@@ -612,25 +651,26 @@ module Arel
         }
       end
 
-      it 'returns string join sql' do
-        manager = Arel::SelectManager.new Table.engine
-        manager.from Nodes::StringJoin.new('hello')
-        manager.join_sql.must_be_like %{ 'hello' }
-      end
+      it "joins itself" do
+        left      = Table.new :users
+        right     = left.alias
+        predicate = left[:id].eq(right[:id])
 
-      it 'returns nil join sql' do
-        manager = Arel::SelectManager.new Table.engine
-        manager.join_sql.must_be_nil
+        mgr = left.join(right)
+        mgr.project Nodes::SqlLiteral.new('*')
+        mgr.on(predicate).must_equal mgr
+
+        mgr.to_sql.must_be_like %{
+           SELECT * FROM "users"
+             INNER JOIN "users" "users_2"
+               ON "users"."id" = "users_2"."id"
+        }
       end
-    end
 
-    describe 'order_clauses' do
-      it 'returns order clauses as a list' do
-        table   = Table.new :users
+      it 'returns string join sql' do
         manager = Arel::SelectManager.new Table.engine
-        manager.from table
-        manager.order table[:id]
-        manager.order_clauses.first.must_be_like %{ "users"."id" }
+        manager.from Nodes::StringJoin.new(Nodes.build_quoted('hello'))
+        assert_match "'hello'", manager.to_sql
       end
     end
 
@@ -692,6 +732,47 @@ module Arel
         }
       end
 
+      it 'takes an order with multiple columns' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').order(table['foo'].asc, table['bar'].desc)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC, "users"."bar" DESC)
+        }
+      end
+
+      it 'takes a partition' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').partition(table['bar'])
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar")
+        }
+      end
+
+      it 'takes a partition and an order' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').partition(table['foo']).order(table['foo'].asc)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."foo"
+            ORDER BY "users"."foo" ASC)
+        }
+      end
+
+      it 'takes a partition with multiple columns' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').partition(table['bar'], table['baz'])
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (PARTITION BY "users"."bar", "users"."baz")
+        }
+      end
+
       it 'takes a rows frame, unbounded preceding' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
@@ -868,12 +949,33 @@ module Arel
     end
 
     describe 'update' do
+
+      it 'creates an update statement' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        stmt = manager.compile_update({table[:id] => 1}, Arel::Attributes::Attribute.new(table, 'id'))
+
+        stmt.to_sql.must_be_like %{
+          UPDATE "users" SET "id" = 1
+        }
+      end
+
+      it 'takes a string' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        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 }
+      end
+
       it 'copies limits' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.take 1
-        stmt = manager.compile_update(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.to_sql.must_be_like %{
@@ -887,7 +989,7 @@ module Arel
         manager = Arel::SelectManager.new Table.engine
         manager.from table
         manager.order :foo
-        stmt = manager.compile_update(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.to_sql.must_be_like %{
@@ -896,15 +998,6 @@ module Arel
         }
       end
 
-      it 'takes a string' do
-        table   = Table.new :users
-        manager = Arel::SelectManager.new Table.engine
-        manager.from table
-        stmt = manager.compile_update(SqlLiteral.new('foo = bar'), Arel::Attributes::Attribute.new(table, 'id'))
-
-        stmt.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
-      end
-
       it 'copies where clauses' do
         table   = Table.new :users
         manager = Arel::SelectManager.new Table.engine
@@ -930,19 +1023,15 @@ module Arel
         }
       end
 
-      it 'executes an update statement' do
-        table   = Table.new :users
-        manager = Arel::SelectManager.new Table.engine
-        manager.from table
-        stmt = manager.compile_update({table[:id] => 1}, Arel::Attributes::Attribute.new(table, 'id'))
-
-        stmt.to_sql.must_be_like %{
-          UPDATE "users" SET "id" = 1
-        }
-      end
     end
 
     describe 'project' do
+      it "takes sql literals" do
+        manager = Arel::SelectManager.new Table.engine
+        manager.project Nodes::SqlLiteral.new '*'
+        manager.to_sql.must_be_like %{ SELECT * }
+      end
+
       it 'takes multiple args' do
         manager = Arel::SelectManager.new Table.engine
         manager.project Nodes::SqlLiteral.new('foo'),
@@ -956,11 +1045,6 @@ module Arel
         manager.to_sql.must_be_like %{ SELECT * }
       end
 
-      it "takes sql literals" do
-        manager = Arel::SelectManager.new Table.engine
-        manager.project Nodes::SqlLiteral.new '*'
-        manager.to_sql.must_be_like %{ SELECT * }
-      end
     end
 
     describe 'projections' do
@@ -1032,24 +1116,6 @@ module Arel
       end
     end
 
-    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('*')
-        mgr.on(predicate).must_equal mgr
-
-        mgr.to_sql.must_be_like %{
-           SELECT * FROM "users"
-             INNER JOIN "users" "users_2"
-               ON "users"."id" = "users_2"."id"
-        }
-      end
-    end
-
     describe 'from' do
       it "makes sql" do
         table   = Table.new :users
@@ -1085,6 +1151,12 @@ module Arel
         manager.distinct(false)
         manager.ast.cores.last.set_quantifier.must_equal nil
       end
+
+      it "chains" do
+        manager = Arel::SelectManager.new Table.engine
+        manager.distinct.must_equal manager
+        manager.distinct(false).must_equal manager
+      end
     end
   end
 end

data/test/test_table.rb

@@ -19,6 +19,13 @@ module Arel
       assert_equal 'bar', join.right
     end
 
+    it 'should create join nodes with a klass' do
+      join = @relation.create_join 'foo', 'bar', Arel::Nodes::FullOuterJoin
+      assert_kind_of Arel::Nodes::FullOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
     it 'should create join nodes with a klass' do
       join = @relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
       assert_kind_of Arel::Nodes::OuterJoin, join
@@ -26,10 +33,18 @@ module Arel
       assert_equal 'bar', join.right
     end
 
+    it 'should create join nodes with a klass' do
+      join = @relation.create_join 'foo', 'bar', Arel::Nodes::RightOuterJoin
+      assert_kind_of Arel::Nodes::RightOuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
     it 'should return an insert manager' do
       im = @relation.compile_insert 'VALUES(NULL)'
       assert_kind_of Arel::InsertManager, im
-      assert_equal 'INSERT INTO NULL VALUES(NULL)', im.to_sql
+      im.into Table.new(:users)
+      assert_equal "INSERT INTO \"users\" VALUES(NULL)", im.to_sql
     end
 
     it 'should return IM from insert_manager' do
@@ -52,6 +67,22 @@ module Arel
       end
     end
 
+    describe 'update_manager' do
+      it 'should return an update manager' do
+        um = @relation.update_manager
+        assert_kind_of Arel::UpdateManager, um
+        assert_equal um.engine, @relation.engine
+      end
+    end
+
+    describe 'delete_manager' do
+      it 'should return a delete manager' do
+        dm = @relation.delete_manager
+        assert_kind_of Arel::DeleteManager, dm
+        assert_equal dm.engine, @relation.engine
+      end
+    end
+
     describe 'having' do
       it 'adds a having clause' do
         mgr = @relation.having @relation[:id].eq(10)
@@ -81,6 +112,20 @@ module Arel
           }
         end
       end
+
+      describe 'join' do
+        it 'creates an outer join' do
+          right     = @relation.alias
+          predicate = @relation[:id].eq(right[:id])
+          mgr = @relation.outer_join(right).on(predicate)
+
+          mgr.to_sql.must_be_like %{
+            SELECT FROM "users"
+              LEFT OUTER JOIN "users" "users_2"
+                ON "users"."id" = "users_2"."id"
+          }
+        end
+      end
     end
 
     describe 'group' do
@@ -130,19 +175,19 @@ module Arel
     describe 'take' do
       it "should add a limit" do
         manager = @relation.take 1
-        manager.project SqlLiteral.new '*'
+        manager.project Nodes::SqlLiteral.new '*'
         manager.to_sql.must_be_like %{ SELECT * FROM "users" LIMIT 1 }
       end
     end
 
     describe 'project' do
       it 'can project' do
-        manager = @relation.project SqlLiteral.new '*'
+        manager = @relation.project Nodes::SqlLiteral.new '*'
         manager.to_sql.must_be_like %{ SELECT * FROM "users" }
       end
 
       it 'takes multiple parameters' do
-        manager = @relation.project SqlLiteral.new('*'), SqlLiteral.new('*')
+        manager = @relation.project Nodes::SqlLiteral.new('*'), Nodes::SqlLiteral.new('*')
         manager.to_sql.must_be_like %{ SELECT *, * FROM "users" }
       end
     end