5 files changed, 30 insertions, 21 deletions
diff --git a/README.markdown b/README.markdown
index f12aa67498..1776330da8 100644
--- a/README.markdown
+++ b/README.markdown
@@ -120,10 +120,10 @@ Aggregate functions `AVG`, `SUM`, `COUNT`, `MIN`, `MAX`, `HAVING`:
 
 ```ruby
 photos.group(photos[:user_id]).having(photos[:id].count.gt(5)) # => SELECT FROM photos GROUP BY photos.user_id HAVING COUNT(photos.id) > 5
-users.project(users[:age].sum) # => SELECT SUM(users.age) AS sum_id FROM users
-users.project(users[:age].average) # => SELECT AVG(users.age) AS avg_id FROM users
-users.project(users[:age].maximum) # => SELECT MAX(users.age) AS max_id FROM users
-users.project(users[:age].minimum) # => SELECT MIN(users.age) AS min_id FROM users
+users.project(users[:age].sum) # => SELECT SUM(users.age) FROM users
+users.project(users[:age].average) # => SELECT AVG(users.age) FROM users
+users.project(users[:age].maximum) # => SELECT MAX(users.age) FROM users
+users.project(users[:age].minimum) # => SELECT MIN(users.age) FROM users
 users.project(users[:age].count) # => SELECT COUNT(users.age) FROM users
 ```
 
@@ -201,7 +201,7 @@ users.
   project(users[:id], cte_table[:click].sum).
   with(composed_cte)
 
-# => WITH cte_table AS (SELECT FROM photos  WHERE photos.created_at > '2014-05-02') SELECT users.id, SUM(cte_table.click) AS sum_id FROM users INNER JOIN cte_table ON users.id = cte_table.user_id
+# => WITH cte_table AS (SELECT FROM photos  WHERE photos.created_at > '2014-05-02') SELECT users.id, SUM(cte_table.click) FROM users INNER JOIN cte_table ON users.id = cte_table.user_id
 ```
 
 When your query is too complex for `Arel`, you can use `Arel::SqlLiteral`:
diff --git a/lib/arel/expressions.rb b/lib/arel/expressions.rb
index fa18f15b67..d40268c292 100644
--- a/lib/arel/expressions.rb
+++ b/lib/arel/expressions.rb
@@ -5,23 +5,24 @@ module Arel
     end
 
     def sum
-      Nodes::Sum.new [self], Nodes::SqlLiteral.new('sum_id')
+      Nodes::Sum.new [self]
     end
 
     def maximum
-      Nodes::Max.new [self], Nodes::SqlLiteral.new('max_id')
+      Nodes::Max.new [self]
     end
 
     def minimum
-      Nodes::Min.new [self], Nodes::SqlLiteral.new('min_id')
+      Nodes::Min.new [self]
     end
 
     def average
-      Nodes::Avg.new [self], Nodes::SqlLiteral.new('avg_id')
+      Nodes::Avg.new [self]
     end
 
     def extract field
       Nodes::Extract.new [self], field
     end
+
   end
 end
diff --git a/lib/arel/visitors/to_sql.rb b/lib/arel/visitors/to_sql.rb
index 8c63070084..ae1b7930af 100644
--- a/lib/arel/visitors/to_sql.rb
+++ b/lib/arel/visitors/to_sql.rb
@@ -436,8 +436,12 @@ module Arel
       end
 
       def visit_Arel_Nodes_Grouping o, collector
-        collector << "("
-        visit(o.expr, collector) << ")"
+        if o.expr.is_a? Nodes::Grouping
+          visit(o.expr, collector)
+        else
+          collector << "("
+          visit(o.expr, collector) << ")"
+        end
       end
 
       def visit_Arel_SelectManager o, collector
diff --git a/test/attributes/test_attribute.rb b/test/attributes/test_attribute.rb
index 50da1cea5b..b50bb60b1e 100644
--- a/test/attributes/test_attribute.rb
+++ b/test/attributes/test_attribute.rb
@@ -82,7 +82,7 @@ module Arel
           mgr = users.project(Arel.star).where(users[:karma].gt(avg))
 
           mgr.to_sql.must_be_like %{
-            SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") AS avg_id FROM "users")
+            SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") FROM "users")
           }
         end
 
@@ -313,12 +313,11 @@ module Arel
           relation[:id].average.must_be_kind_of Nodes::Avg
         end
 
-        # FIXME: backwards compat. Is this really necessary?
-        it 'should set the alias to "avg_id"' do
+        it 'should generate the proper SQL' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id].average
           mgr.to_sql.must_be_like %{
-            SELECT AVG("users"."id") AS avg_id
+            SELECT AVG("users"."id")
             FROM "users"
           }
         end
@@ -330,12 +329,11 @@ module Arel
           relation[:id].maximum.must_be_kind_of Nodes::Max
         end
 
-        # FIXME: backwards compat. Is this really necessary?
-        it 'should set the alias to "max_id"' do
+        it 'should generate the proper SQL' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id].maximum
           mgr.to_sql.must_be_like %{
-            SELECT MAX("users"."id") AS max_id
+            SELECT MAX("users"."id")
             FROM "users"
           }
         end
@@ -354,12 +352,11 @@ module Arel
           relation[:id].sum.must_be_kind_of Nodes::Sum
         end
 
-        # FIXME: backwards compat. Is this really necessary?
-        it 'should set the alias to "sum_id"' do
+        it 'should generate the proper SQL' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id].sum
           mgr.to_sql.must_be_like %{
-            SELECT SUM("users"."id") AS sum_id
+            SELECT SUM("users"."id")
             FROM "users"
           }
         end
diff --git a/test/visitors/test_to_sql.rb b/test/visitors/test_to_sql.rb
index a88c888908..c03d89cfef 100644
--- a/test/visitors/test_to_sql.rb
+++ b/test/visitors/test_to_sql.rb
@@ -131,6 +131,13 @@ module Arel
         end
       end
 
+      describe 'Nodes::Grouping' do
+        it 'wraps nested groupings in brackets only once' do
+          sql = compile Nodes::Grouping.new(Nodes::Grouping.new(Nodes.build_quoted('foo')))
+          sql.must_equal "('foo')"
+        end
+      end
+
       describe 'Nodes::NotEqual' do
         it 'should handle false' do
           val = Nodes.build_quoted(false, @table[:active])