arel 7.0.0 → 7.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7b8575f1877fe831a05c70632e7046c6ce384c9
-  data.tar.gz: ab4c6895e273c5ad2bd6456bdf2f0fd1b3f7e0a2
+  metadata.gz: 2342eabbd34e994cf145023635cfe2da0c06cdf1
+  data.tar.gz: 044e71730354450e808cc454d89b8c362b2c8248
 SHA512:
-  metadata.gz: 71feebe60212b48f1bce1fe0acc756728aff663f7e84836bc5888ed237bc6315b22d95993d9b9fce655dbccbf35c75652e9fd62c185d141c0c246084e3d70e68
-  data.tar.gz: 563e00ae3191b5d4be40b8ead9168ead202242593a9761a2a5e938454b13c3094542d83b2e3ca5706c572ca2d1551772a9bce80631e55be9aa3379435bfecb75
+  metadata.gz: 14fd92387019cbab3bd4a102d0bddf0de1870eb16308054c69488d5d33a7692250f8e4c833ee0b7c76079fb8ed77778e98c55dc3da5f74a9726c793312661cda
+  data.tar.gz: ee5a6f43ddfae8c144f300fc7cb387bb0b836cb9cbbdbd8e1b597d22ed3493ee49a60656ac9ca1420bf9404a406d7a3ccd2fc5eda8281c03cb5ffb616654fe56

data/History.txt

@@ -1,3 +1,11 @@
+=== 7.1.0 / 2016-07-19
+
+* Enhancements
+
+  * Support Ruby 2.4 unified Integer class
+  * Implement `CASE` conditional expression
+  * Support for Bitwise Operations as `InfixOperations`
+
 === 7.0.0 / 2015-12-17
 
 * Enhancements

data/MIT-LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2007-2015 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
+Copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/{README.markdown → README.md}

@@ -8,8 +8,8 @@ Arel Really Exasperates Logicians
 
 Arel is a SQL AST manager for Ruby. It
 
-1. Simplifies the generation of complex SQL queries
-2. Adapts to various RDBMSes
+1. simplifies the generation of complex SQL queries, and
+2. adapts to various RDBMSes.
 
 It is intended to be a framework framework; that is, you can build your own ORM
 with it, focusing on innovative object and collection modeling as opposed to
@@ -17,7 +17,7 @@ database compatibility and query generation.
 
 ## Status
 
-For the moment, Arel uses Active Record's connection adapters to connect to the various engines, connection pooling, perform quoting, and do type conversion.
+For the moment, Arel uses Active Record's connection adapters to connect to the various engines and perform connection pooling, quoting, and type conversion.
 
 ## A Gentle Introduction
 
@@ -27,7 +27,7 @@ Generating a query with Arel is simple. For example, in order to produce
 SELECT * FROM users
 ```
 
-you construct a table relation and convert it to sql:
+you construct a table relation and convert it to SQL:
 
 ```ruby
 users = Arel::Table.new(:users)
@@ -56,13 +56,48 @@ users.project(users[:id])
 Comparison operators `=`, `!=`, `<`, `>`, `<=`, `>=`, `IN`:
 
 ```ruby
-users.where(users[:age].eq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" = 10
-users.where(users[:age].not_eq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" != 10
-users.where(users[:age].lt(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" < 10
-users.where(users[:age].gt(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" > 10
-users.where(users[:age].lteq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" <= 10
-users.where(users[:age].gteq(10)).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" >= 10
-users.where(users[:age].in([20, 16, 17])).project(Arel.sql('*')) # => SELECT * FROM "users"  WHERE "users"."age" IN (20, 16, 17)
+users.where(users[:age].eq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" = 10
+
+users.where(users[:age].not_eq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" != 10
+
+users.where(users[:age].lt(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" < 10
+
+users.where(users[:age].gt(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" > 10
+
+users.where(users[:age].lteq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" <= 10
+
+users.where(users[:age].gteq(10)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" >= 10
+
+users.where(users[:age].in([20, 16, 17])).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE "users"."age" IN (20, 16, 17)
+```
+
+Bitwise operators `&`, `|`, `^`, `<<`, `>>`:
+
+```ruby
+users.where((users[:bitmap] & 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" & 16) > 0
+
+users.where((users[:bitmap] | 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" | 16) > 0
+
+users.where((users[:bitmap] ^ 16).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" ^ 16) > 0
+
+users.where((users[:bitmap] << 1).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" << 1) > 0
+
+users.where((users[:bitmap] >> 1).gt(0)).project(Arel.sql('*'))
+# => SELECT * FROM "users"  WHERE ("users"."bitmap" >> 1) > 0
+
+users.where((~ users[:bitmap]).gt(0)).project(Arel.sql('*'))
+# => SELECT FROM "users" WHERE  ~ "users"."bitmap" > 0
 ```
 
 Joins resemble SQL strongly:
@@ -72,7 +107,7 @@ users.join(photos).on(users[:id].eq(photos[:user_id]))
 # => SELECT * FROM users INNER JOIN photos ON users.id = photos.user_id
 ```
 
-Left Joins
+Left joins:
 
 ```ruby
 users.join(photos, Arel::Nodes::OuterJoin).on(users[:id].eq(photos[:user_id]))
@@ -93,7 +128,7 @@ users.project(users[:name]).group(users[:name])
 # => SELECT users.name FROM users GROUP BY users.name
 ```
 
-The best property of arel is its "composability", or closure under all operations. For example, to restrict AND project, just "chain" the method invocations:
+The best property of Arel is its "composability," or closure under all operations. For example, to restrict AND project, just "chain" the method invocations:
 
 ```ruby
 users                                 \
@@ -119,23 +154,35 @@ The `AND` operator behaves similarly.
 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) 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
+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) 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
 ```
 
 Aliasing Aggregate Functions:
 
 ```ruby
-users.project(users[:age].average.as("mean_age")) # => SELECT AVG(users.age) AS mean_age FROM users
+users.project(users[:age].average.as("mean_age"))
+# => SELECT AVG(users.age) AS mean_age FROM users
 ```
 
 ### The Crazy Features
 
-The examples above are fairly simple and other libraries match or come close to matching the expressiveness of Arel (e.g., `Sequel` in Ruby).
+The examples above are fairly simple and other libraries match or come close to matching the expressiveness of Arel (e.g. `Sequel` in Ruby).
 
 #### Inline math operations
 
@@ -179,12 +226,13 @@ Joining a table to itself requires aliasing in SQL. This aliasing can be handled
 replies = comments.alias
 comments_with_replies = \
   comments.join(replies).on(replies[:parent_id].eq(comments[:id])).where(comments[:id].eq(1))
-# => SELECT * FROM comments INNER JOIN comments AS comments_2 WHERE comments_2.parent_id = comments.id AND comments.id = 1
+# => SELECT * FROM comments INNER JOIN comments AS comments_2
+#    WHERE comments_2.parent_id = comments.id AND comments.id = 1
 ```
 
 This will return the reply for the first comment.
 
-[Common Table Expressions(CTE)](https://en.wikipedia.org/wiki/Common_table_expressions#Common_table_expression) support via:
+[Common Table Expressions (CTE)](https://en.wikipedia.org/wiki/Common_table_expressions#Common_table_expression) support via:
 
 Create a `CTE`
 
@@ -201,7 +249,9 @@ 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) 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`:
@@ -214,17 +264,18 @@ photo_clicks = Arel::Nodes::SqlLiteral.new(<<-SQL
     ELSE default_calculation END
 SQL
 )
+
 photos.project(photo_clicks.as("photo_clicks"))
 # => SELECT CASE WHEN condition1 THEN calculation1
-    WHEN condition2 THEN calculation2
-    WHEN condition3 THEN calculation3
-    ELSE default_calculation END
- FROM "photos"
+#    WHEN condition2 THEN calculation2
+#    WHEN condition3 THEN calculation3
+#    ELSE default_calculation END
+#    FROM "photos"
 ```
 
 ## Contributing to Arel
 
-Arel is work of many contributors. You're encouraged to submit pull requests, propose
+Arel is the work of many contributors. You're encouraged to submit pull requests, propose
 features and discuss issues.
 
 See [CONTRIBUTING](CONTRIBUTING.md).

data/lib/arel.rb

@@ -21,7 +21,7 @@ require 'arel/delete_manager'
 require 'arel/nodes'
 
 module Arel
-  VERSION = '7.0.0'
+  VERSION = '7.1.0'
 
   def self.sql raw_sql
     Arel::Nodes::SqlLiteral.new raw_sql

data/lib/arel/math.rb

@@ -15,5 +15,29 @@ module Arel
     def /(other)
       Arel::Nodes::Division.new(self, other)
     end
+
+    def &(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseAnd.new(self, other))
+    end
+
+    def |(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseOr.new(self, other))
+    end
+
+    def ^(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseXor.new(self, other))
+    end
+
+    def <<(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftLeft.new(self, other))
+    end
+
+    def >>(other)
+      Arel::Nodes::Grouping.new(Arel::Nodes::BitwiseShiftRight.new(self, other))
+    end
+
+    def ~@
+      Arel::Nodes::BitwiseNot.new(self)
+    end
   end
 end

data/lib/arel/nodes.rb

@@ -28,6 +28,7 @@ require 'arel/nodes/join_source'
 require 'arel/nodes/delete_statement'
 require 'arel/nodes/table_alias'
 require 'arel/nodes/infix_operation'
+require 'arel/nodes/unary_operation'
 require 'arel/nodes/over'
 require 'arel/nodes/matches'
 require 'arel/nodes/regexp'
@@ -47,6 +48,9 @@ require 'arel/nodes/named_function'
 # windows
 require 'arel/nodes/window'
 
+# conditional expressions
+require 'arel/nodes/case'
+
 # joins
 require 'arel/nodes/full_outer_join'
 require 'arel/nodes/inner_join'

data/lib/arel/nodes/case.rb

@@ -0,0 +1,57 @@
+module Arel
+  module Nodes
+    class Case < Arel::Nodes::Node
+      include Arel::OrderPredications
+      include Arel::Predications
+      include Arel::AliasPredication
+
+      attr_accessor :case, :conditions, :default
+
+      def initialize expression = nil, default = nil
+        @case = expression
+        @conditions = []
+        @default = default
+      end
+
+      def when condition, expression = nil
+        @conditions << When.new(Nodes.build_quoted(condition), expression)
+        self
+      end
+
+      def then expression
+        @conditions.last.right = Nodes.build_quoted(expression)
+        self
+      end
+
+      def else expression
+        @default = Else.new Nodes.build_quoted(expression)
+        self
+      end
+
+      def initialize_copy other
+        super
+        @case = @case.clone if @case
+        @conditions = @conditions.map { |x| x.clone }
+        @default = @default.clone if @default
+      end
+
+      def hash
+        [@case, @conditions, @default].hash
+      end
+
+      def eql? other
+        self.class == other.class &&
+          self.case == other.case &&
+          self.conditions == other.conditions &&
+          self.default == other.default
+      end
+      alias :== :eql?
+    end
+
+    class When < Binary # :nodoc:
+    end
+
+    class Else < Unary # :nodoc:
+    end
+  end
+end

data/lib/arel/nodes/casted.rb

@@ -10,6 +10,10 @@ module Arel
 
       def nil?; @val.nil?; end
 
+      def hash
+         [@class, @val, @attribute].hash
+      end
+
       def eql? other
         self.class == other.class &&
             self.val == other.val &&

data/lib/arel/nodes/infix_operation.rb

@@ -40,5 +40,40 @@ module Arel
       end
     end
 
+    class Concat < InfixOperation
+      def initialize left, right
+        super('||', left, right)
+      end
+    end
+
+    class BitwiseAnd < InfixOperation
+      def initialize left, right
+        super(:&, left, right)
+      end
+    end
+
+    class BitwiseOr < InfixOperation
+      def initialize left, right
+        super(:|, left, right)
+      end
+    end
+
+    class BitwiseXor < InfixOperation
+      def initialize left, right
+        super(:^, left, right)
+      end
+    end
+
+    class BitwiseShiftLeft < InfixOperation
+      def initialize left, right
+        super(:<<, left, right)
+      end
+    end
+
+    class BitwiseShiftRight < InfixOperation
+      def initialize left, right
+        super(:>>, left, right)
+      end
+    end
   end
-end
+end

data/lib/arel/nodes/unary.rb

@@ -22,15 +22,19 @@ module Arel
 
     %w{
       Bin
+      Cube
+      DistinctOn
       Group
+      GroupingElement
+      GroupingSet
       Limit
+      Lock
       Not
       Offset
       On
       Ordering
+      RollUp
       Top
-      Lock
-      DistinctOn
     }.each do |name|
       const_set(name, Class.new(Unary))
     end

data/lib/arel/nodes/unary_operation.rb

@@ -0,0 +1,25 @@
+module Arel
+  module Nodes
+
+    class UnaryOperation < Unary
+      include Arel::Expressions
+      include Arel::Predications
+      include Arel::OrderPredications
+      include Arel::AliasPredication
+      include Arel::Math
+
+      attr_reader :operator
+
+      def initialize operator, operand
+        super(operand)
+        @operator = operator
+      end
+    end
+
+    class BitwiseNot < UnaryOperation
+      def initialize operand
+        super(:~, operand)
+      end
+    end
+  end
+end

data/lib/arel/predications.rb

@@ -198,6 +198,14 @@ Passing a range to `#not_in` is deprecated. Call `#not_between`, instead.
       grouping_all :lteq, others
     end
 
+    def when right
+      Nodes::Case.new(self).when quoted_node(right)
+    end
+
+    def concat other
+      Nodes::Concat.new self, other
+    end
+
     private
 
     def grouping_any method_id, others, *extras

data/lib/arel/visitors.rb

@@ -14,28 +14,5 @@ require 'arel/visitors/informix'
 
 module Arel
   module Visitors
-    VISITORS = {
-      'postgresql'      => Arel::Visitors::PostgreSQL,
-      'mysql'           => Arel::Visitors::MySQL,
-      'mysql2'          => Arel::Visitors::MySQL,
-      'mssql'           => Arel::Visitors::MSSQL,
-      'sqlserver'       => Arel::Visitors::MSSQL,
-      'oracle_enhanced' => Arel::Visitors::Oracle,
-      'sqlite'          => Arel::Visitors::SQLite,
-      'sqlite3'         => Arel::Visitors::SQLite,
-      'ibm_db'          => Arel::Visitors::IBM_DB,
-      'informix'        => Arel::Visitors::Informix,
-    }
-
-    ENGINE_VISITORS = Hash.new do |hash, engine|
-      pool         = engine.connection_pool
-      adapter      = pool.spec.config[:adapter]
-      hash[engine] = (VISITORS[adapter] || Visitors::ToSql).new(engine)
-    end
-
-    def self.visitor_for engine
-      ENGINE_VISITORS[engine]
-    end
-    class << self; alias :for :visitor_for; end
   end
 end

data/lib/arel/visitors/depth_first.rb

@@ -16,7 +16,12 @@ module Arel
       def unary o
         visit o.expr
       end
+      alias :visit_Arel_Nodes_Else              :unary
       alias :visit_Arel_Nodes_Group             :unary
+      alias :visit_Arel_Nodes_Cube              :unary
+      alias :visit_Arel_Nodes_RollUp            :unary
+      alias :visit_Arel_Nodes_GroupingSet       :unary
+      alias :visit_Arel_Nodes_GroupingElement   :unary
       alias :visit_Arel_Nodes_Grouping          :unary
       alias :visit_Arel_Nodes_Having            :unary
       alias :visit_Arel_Nodes_Limit             :unary
@@ -53,6 +58,12 @@ module Arel
         visit o.distinct
       end
 
+      def visit_Arel_Nodes_Case o
+        visit o.case
+        visit o.conditions
+        visit o.default
+      end
+
       def nary o
         o.children.each { |child| visit child}
       end
@@ -65,6 +76,7 @@ module Arel
       alias :visit_Arel_Nodes_As                 :binary
       alias :visit_Arel_Nodes_Assignment         :binary
       alias :visit_Arel_Nodes_Between            :binary
+      alias :visit_Arel_Nodes_Concat             :binary
       alias :visit_Arel_Nodes_DeleteStatement    :binary
       alias :visit_Arel_Nodes_DoesNotMatch       :binary
       alias :visit_Arel_Nodes_Equality           :binary
@@ -86,8 +98,9 @@ module Arel
       alias :visit_Arel_Nodes_Regexp             :binary
       alias :visit_Arel_Nodes_RightOuterJoin     :binary
       alias :visit_Arel_Nodes_TableAlias         :binary
-      alias :visit_Arel_Nodes_Values             :binary
       alias :visit_Arel_Nodes_Union              :binary
+      alias :visit_Arel_Nodes_Values             :binary
+      alias :visit_Arel_Nodes_When               :binary
 
       def visit_Arel_Nodes_StringJoin o
         visit o.left
@@ -128,6 +141,7 @@ module Arel
       alias :visit_FalseClass                    :terminal
       alias :visit_Fixnum                        :terminal
       alias :visit_Float                         :terminal
+      alias :visit_Integer                       :terminal
       alias :visit_NilClass                      :terminal
       alias :visit_String                        :terminal
       alias :visit_Symbol                        :terminal

data/lib/arel/visitors/dot.rb

@@ -69,6 +69,10 @@ module Arel
         visit_edge o, "expr"
       end
       alias :visit_Arel_Nodes_Group             :unary
+      alias :visit_Arel_Nodes_Cube              :unary
+      alias :visit_Arel_Nodes_RollUp            :unary
+      alias :visit_Arel_Nodes_GroupingSet       :unary
+      alias :visit_Arel_Nodes_GroupingElement   :unary
       alias :visit_Arel_Nodes_Grouping          :unary
       alias :visit_Arel_Nodes_Having            :unary
       alias :visit_Arel_Nodes_Limit             :unary
@@ -176,6 +180,7 @@ module Arel
       alias :visit_Arel_Nodes_As                 :binary
       alias :visit_Arel_Nodes_Assignment         :binary
       alias :visit_Arel_Nodes_Between            :binary
+      alias :visit_Arel_Nodes_Concat             :binary
       alias :visit_Arel_Nodes_DoesNotMatch       :binary
       alias :visit_Arel_Nodes_Equality           :binary
       alias :visit_Arel_Nodes_GreaterThan        :binary
@@ -200,6 +205,7 @@ module Arel
       alias :visit_TrueClass :visit_String
       alias :visit_FalseClass :visit_String
       alias :visit_Arel_Nodes_BindParam :visit_String
+      alias :visit_Integer :visit_String
       alias :visit_Fixnum :visit_String
       alias :visit_BigDecimal :visit_String
       alias :visit_Float :visit_String

data/lib/arel/visitors/mysql.rb

@@ -72,6 +72,14 @@ module Arel
         maybe_visit o.limit, collector
       end
 
+      def visit_Arel_Nodes_Concat o, collector
+        collector << " CONCAT("
+        visit o.left, collector
+        collector << ", "
+        visit o.right, collector
+        collector << ") "
+        collector
+      end
     end
   end
 end

data/lib/arel/visitors/oracle12.rb

@@ -6,10 +6,12 @@ module Arel
       def visit_Arel_Nodes_SelectStatement o, collector
         # Oracle does not allow LIMIT clause with select for update
         if o.limit && o.lock
-          o = o.dup
-          o.limit = []
+          raise ArgumentError, <<-MSG
+            'Combination of limit and lock is not supported.
+            because generated SQL statements
+            `SELECT FOR UPDATE and FETCH FIRST n ROWS` generates ORA-02014.`
+          MSG
         end
-
         super
       end
 
@@ -48,6 +50,10 @@ module Arel
 
         super
       end
+
+      def visit_Arel_Nodes_BindParam o, collector
+        collector.add_bind(o) { |i| ":a#{i}" }
+      end
     end
   end
 end

data/lib/arel/visitors/postgresql.rb

@@ -1,6 +1,10 @@
 module Arel
   module Visitors
     class PostgreSQL < Arel::Visitors::ToSql
+      CUBE = 'CUBE'
+      ROLLUP = 'ROLLUP'
+      GROUPING_SET = 'GROUPING SET'
+
       private
 
       def visit_Arel_Nodes_Matches o, collector
@@ -43,6 +47,38 @@ module Arel
       def visit_Arel_Nodes_BindParam o, collector
         collector.add_bind(o) { |i| "$#{i}" }
       end
+
+      def visit_Arel_Nodes_GroupingElement o, collector
+        collector << "( "
+        visit(o.expr, collector) << " )"
+      end
+
+      def visit_Arel_Nodes_Cube o, collector
+        collector << CUBE
+        grouping_array_or_grouping_element o, collector
+      end
+
+      def visit_Arel_Nodes_RollUp o, collector
+        collector << ROLLUP
+        grouping_array_or_grouping_element o, collector
+      end
+
+      def visit_Arel_Nodes_GroupingSet o, collector
+        collector << GROUPING_SET
+        grouping_array_or_grouping_element o, collector
+      end
+
+      # Utilized by GroupingSet, Cube & RollUp visitors to
+      # handle grouping aggregation semantics
+      def grouping_array_or_grouping_element o, collector
+        if o.expr.is_a? Array
+          collector << "( "
+          visit o.expr, collector
+          collector << " )"
+        else
+          visit o.expr, collector
+        end
+      end
     end
   end
 end

data/lib/arel/visitors/sqlite.rb

@@ -12,6 +12,15 @@ module Arel
         o.limit = Arel::Nodes::Limit.new(-1) if o.offset && !o.limit
         super
       end
+
+      def visit_Arel_Nodes_True o, collector
+        collector << "1"
+      end
+
+      def visit_Arel_Nodes_False o, collector
+        collector << "0"
+      end
+
     end
   end
 end

data/lib/arel/visitors/to_sql.rb

@@ -199,7 +199,7 @@ module Arel
             collector << quote(value, attr && column_for(attr)).to_s
           end
           unless i == len
-            collector << ', '
+            collector << COMMA
           end
         }
 
@@ -243,53 +243,33 @@ module Arel
 
         collector = maybe_visit o.set_quantifier, collector
 
-        unless o.projections.empty?
-          collector << SPACE
-          len = o.projections.length - 1
-          o.projections.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
+        collect_nodes_for o.projections, collector, SPACE
 
         if o.source && !o.source.empty?
           collector << " FROM "
           collector = visit o.source, collector
         end
 
-        unless o.wheres.empty?
-          collector << WHERE
-          len = o.wheres.length - 1
-          o.wheres.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << AND unless len == i
-          end
-        end
-
-        unless o.groups.empty?
-          collector << GROUP_BY
-          len = o.groups.length - 1
-          o.groups.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
-
+        collect_nodes_for o.wheres, collector, WHERE, AND
+        collect_nodes_for o.groups, collector, GROUP_BY
         unless o.havings.empty?
           collector << " HAVING "
           inject_join o.havings, collector, AND
         end
+        collect_nodes_for o.windows, collector, WINDOW
 
-        unless o.windows.empty?
-          collector << WINDOW
-          len = o.windows.length - 1
-          o.windows.each_with_index do |x, i|
+        collector
+      end
+
+      def collect_nodes_for nodes, collector, spacer, connector = COMMA
+        unless nodes.empty?
+          collector << spacer
+          len = nodes.length - 1
+          nodes.each_with_index do |x, i|
             collector = visit(x, collector)
-            collector << COMMA unless len == i
+            collector << connector unless len == i
           end
         end
-
-        collector
       end
 
       def visit_Arel_Nodes_Bin o, collector
@@ -349,13 +329,13 @@ module Arel
         end
 
         if o.orders.any?
-          collector << ' ' if o.partitions.any?
+          collector << SPACE if o.partitions.any?
           collector << "ORDER BY "
           collector = inject_join o.orders, collector, ", "
         end
 
         if o.framing
-          collector << ' ' if o.partitions.any? or o.orders.any?
+          collector << SPACE if o.partitions.any? or o.orders.any?
           collector = visit o.framing, collector
         end
 
@@ -564,7 +544,7 @@ module Arel
           collector = visit o.left, collector
         end
         if o.right.any?
-          collector << " " if o.left
+          collector << SPACE if o.left
           collector = inject_join o.right, collector, ' '
         end
         collector
@@ -708,6 +688,35 @@ module Arel
         visit o.right, collector
       end
 
+      def visit_Arel_Nodes_Case o, collector
+        collector << "CASE "
+        if o.case
+          visit o.case, collector
+          collector << " "
+        end
+        o.conditions.each do |condition|
+          visit condition, collector
+          collector << " "
+        end
+        if o.default
+          visit o.default, collector
+          collector << " "
+        end
+        collector << "END"
+      end
+
+      def visit_Arel_Nodes_When o, collector
+        collector << "WHEN "
+        visit o.left, collector
+        collector << " THEN "
+        visit o.right, collector
+      end
+
+      def visit_Arel_Nodes_Else o, collector
+        collector << "ELSE "
+        visit o.expr, collector
+      end
+
       def visit_Arel_Nodes_UnqualifiedColumn o, collector
         collector << "#{quote_column_name o.name}"
         collector
@@ -733,6 +742,7 @@ module Arel
       alias :visit_Arel_Nodes_SqlLiteral :literal
       alias :visit_Bignum                :literal
       alias :visit_Fixnum                :literal
+      alias :visit_Integer               :literal
 
       def quoted o, a
         if a && a.able_to_type_cast?
@@ -772,6 +782,11 @@ module Arel
       alias :visit_Arel_Nodes_Multiplication :visit_Arel_Nodes_InfixOperation
       alias :visit_Arel_Nodes_Division       :visit_Arel_Nodes_InfixOperation
 
+      def visit_Arel_Nodes_UnaryOperation o, collector
+        collector << " #{o.operator} "
+        visit o.expr, collector
+      end
+
       def visit_Array o, collector
         inject_join o, collector, ", "
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arel
 version: !ruby/object:Gem::Version
-  version: 7.0.0
+  version: 7.1.0
 platform: ruby
 authors:
 - Aaron Patterson
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-17 00:00:00.000000000 Z
+date: 2016-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -75,11 +75,11 @@ extensions: []
 extra_rdoc_files:
 - History.txt
 - MIT-LICENSE.txt
-- README.markdown
+- README.md
 files:
 - History.txt
 - MIT-LICENSE.txt
-- README.markdown
+- README.md
 - lib/arel.rb
 - lib/arel/alias_predication.rb
 - lib/arel/attributes.rb
@@ -99,6 +99,7 @@ files:
 - lib/arel/nodes/ascending.rb
 - lib/arel/nodes/binary.rb
 - lib/arel/nodes/bind_param.rb
+- lib/arel/nodes/case.rb
 - lib/arel/nodes/casted.rb
 - lib/arel/nodes/count.rb
 - lib/arel/nodes/delete_statement.rb
@@ -129,6 +130,7 @@ files:
 - lib/arel/nodes/terminal.rb
 - lib/arel/nodes/true.rb
 - lib/arel/nodes/unary.rb
+- lib/arel/nodes/unary_operation.rb
 - lib/arel/nodes/unqualified_column.rb
 - lib/arel/nodes/update_statement.rb
 - lib/arel/nodes/values.rb
@@ -165,7 +167,7 @@ metadata: {}
 post_install_message: 
 rdoc_options:
 - "--main"
-- README.markdown
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -180,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: Arel Really Exasperates Logicians  Arel is a SQL AST manager for Ruby