arel 5.0.1.20140414130214 → 6.0.0.beta1

data/lib/arel/visitors/sqlite.rb

@@ -4,10 +4,11 @@ module Arel
       private
 
       # Locks are not supported in SQLite
-      def visit_Arel_Nodes_Lock o, a
+      def visit_Arel_Nodes_Lock o, collector
+        collector
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Nodes_SelectStatement o, collector
         o.limit = Arel::Nodes::Limit.new(-1) if o.offset && !o.limit
         super
       end

data/lib/arel/visitors/to_sql.rb

@@ -1,9 +1,10 @@
 require 'bigdecimal'
 require 'date'
+require 'arel/visitors/reduce'
 
 module Arel
   module Visitors
-    class ToSql < Arel::Visitors::Visitor
+    class ToSql < Arel::Visitors::Reduce
       ##
       # This is some roflscale crazy stuff.  I'm roflscaling this because
       # building SQL queries is a hotspot.  I will explain the roflscale so that
@@ -64,13 +65,21 @@ module Arel
         @quoted_columns = {}
       end
 
+      def compile node, &block
+        accept(node, Arel::Collectors::SQLString.new, &block).value
+      end
+
       private
 
-      def visit_Arel_Nodes_DeleteStatement o, a
-        [
-          "DELETE FROM #{visit o.relation}",
-          ("WHERE #{o.wheres.map { |x| visit x }.join AND}" unless o.wheres.empty?)
-        ].compact.join ' '
+      def visit_Arel_Nodes_DeleteStatement o, collector
+        collector << "DELETE FROM "
+        collector = visit o.relation, collector
+        if o.wheres.any?
+          collector << " WHERE "
+          inject_join o.wheres, collector, AND
+        else
+          collector
+        end
       end
 
       # FIXME: we should probably have a 2-pass visitor for this
@@ -85,43 +94,71 @@ module Arel
         stmt
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
+      def visit_Arel_Nodes_UpdateStatement o, collector
         if o.orders.empty? && o.limit.nil?
           wheres = o.wheres
         else
           wheres = [Nodes::In.new(o.key, [build_subselect(o.key, o)])]
         end
 
-        [
-          "UPDATE #{visit o.relation, a}",
-          ("SET #{o.values.map { |value| visit value, a }.join ', '}" unless o.values.empty?),
-          ("WHERE #{wheres.map { |x| visit x, a }.join ' AND '}" unless wheres.empty?),
-        ].compact.join ' '
+        collector << "UPDATE "
+        collector = visit o.relation, collector
+        unless o.values.empty?
+          collector << " SET "
+          collector = inject_join o.values, collector, ", "
+        end
+
+        unless wheres.empty?
+          collector << " WHERE "
+          collector = inject_join wheres, collector, " AND "
+        end
+
+        collector
       end
 
-      def visit_Arel_Nodes_InsertStatement o, a
-        [
-          "INSERT INTO #{visit o.relation, a}",
+      def visit_Arel_Nodes_InsertStatement o, collector
+        collector << "INSERT INTO "
+        collector = visit o.relation, collector
+        if o.columns.any?
+          collector << " (#{o.columns.map { |x|
+            quote_column_name x.name
+          }.join ', '})"
+        end
 
-          ("(#{o.columns.map { |x|
-          quote_column_name x.name
-        }.join ', '})" unless o.columns.empty?),
+        if o.values
+          maybe_visit o.values, collector
+        elsif o.select
+          maybe_visit o.select, collector
+        else
+          collector
+        end
+      end
 
-          (visit o.values, a if o.values),
-        ].compact.join ' '
+      def visit_Arel_Nodes_Exists o, collector
+        collector << "EXISTS ("
+        collector = visit(o.expressions, collector) << ")"
+        if o.alias
+          collector << " AS "
+          visit o.alias, collector
+        else
+          collector
+        end
       end
 
-      def visit_Arel_Nodes_Exists o, a
-        "EXISTS (#{visit o.expressions, a})#{
-          o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Casted o, collector
+        collector << quoted(o.val, o.attribute).to_s
       end
 
-      def visit_Arel_Nodes_True o, a
-        "TRUE"
+      def visit_Arel_Nodes_Quoted o, collector
+        collector << quoted(o.expr, nil).to_s
       end
 
-      def visit_Arel_Nodes_False o, a
-        "FALSE"
+      def visit_Arel_Nodes_True o, collector
+        collector << "TRUE"
+      end
+
+      def visit_Arel_Nodes_False o, collector
+        collector << "FALSE"
       end
 
       def table_exists? name
@@ -142,402 +179,527 @@ module Arel
         @schema_cache.columns_hash(table)
       end
 
-      def visit_Arel_Nodes_Values o, a
-        "VALUES (#{o.expressions.zip(o.columns).map { |value, attr|
+      def visit_Arel_Nodes_Values o, collector
+        collector << "VALUES ("
+
+        len = o.expressions.length - 1
+        o.expressions.zip(o.columns).each_with_index { |(value, attr), i|
           if Nodes::SqlLiteral === value
-            visit value, a
+            collector = visit value, collector
           else
-            quote(value, attr && column_for(attr))
+            collector << quote(value, attr && column_for(attr)).to_s
           end
-        }.join ', '})"
-      end
+          unless i == len
+            collector << ', '
+          end
+        }
 
-      def visit_Arel_Nodes_SelectStatement o, a
-        str = ''
+        collector << ")"
+      end
 
+      def visit_Arel_Nodes_SelectStatement o, collector
         if o.with
-          str << visit(o.with, a)
-          str << SPACE
+          collector = visit o.with, collector
+          collector << SPACE
         end
 
-        o.cores.each { |x| str << visit_Arel_Nodes_SelectCore(x, a) }
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore(x, c)
+        }
 
         unless o.orders.empty?
-          str << SPACE
-          str << ORDER_BY
+          collector << SPACE
+          collector << ORDER_BY
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
-            str << visit(x, a)
-            str << COMMA unless len == i
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
           }
         end
 
-        str << " #{visit(o.limit, a)}" if o.limit
-        str << " #{visit(o.offset, a)}" if o.offset
-        str << " #{visit(o.lock, a)}" if o.lock
+        collector = maybe_visit o.limit, collector
+        collector = maybe_visit o.offset, collector
+        collector = maybe_visit o.lock, collector
 
-        str.strip!
-        str
+        collector
       end
 
-      def visit_Arel_Nodes_SelectCore o, a
-        str = "SELECT"
+      def visit_Arel_Nodes_SelectCore o, collector
+        collector << "SELECT"
 
-        str << " #{visit(o.top, a)}"            if o.top
-        str << " #{visit(o.set_quantifier, a)}" if o.set_quantifier
+        if o.top
+          collector << " "
+          collector = visit o.top, collector
+        end
+
+        if o.set_quantifier
+          collector << " "
+          collector = visit o.set_quantifier, collector
+        end
 
         unless o.projections.empty?
-          str << SPACE
+          collector << SPACE
           len = o.projections.length - 1
           o.projections.each_with_index do |x, i|
-            str << visit(x, a)
-            str << COMMA unless len == i
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
           end
         end
 
-        str << " FROM #{visit(o.source, a)}" if o.source && !o.source.empty?
+        if o.source && !o.source.empty?
+          collector << " FROM "
+          collector = visit o.source, collector
+        end
 
         unless o.wheres.empty?
-          str << WHERE
+          collector << WHERE
           len = o.wheres.length - 1
           o.wheres.each_with_index do |x, i|
-            str << visit(x, a)
-            str << AND unless len == i
+            collector = visit(x, collector)
+            collector << AND unless len == i
           end
         end
 
         unless o.groups.empty?
-          str << GROUP_BY
+          collector << GROUP_BY
           len = o.groups.length - 1
           o.groups.each_with_index do |x, i|
-            str << visit(x, a)
-            str << COMMA unless len == i
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
           end
         end
 
-        str << " #{visit(o.having, a)}" if o.having
+        if o.having
+          collector << " "
+          collector = visit(o.having, collector)
+        end
 
         unless o.windows.empty?
-          str << WINDOW
+          collector << WINDOW
           len = o.windows.length - 1
           o.windows.each_with_index do |x, i|
-            str << visit(x, a)
-            str << COMMA unless len == i
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
           end
         end
 
-        str
+        collector
       end
 
-      def visit_Arel_Nodes_Bin o, a
-        visit o.expr, a
+      def visit_Arel_Nodes_Bin o, collector
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Distinct o, a
-        DISTINCT
+      def visit_Arel_Nodes_Distinct o, collector
+        collector << DISTINCT
       end
 
-      def visit_Arel_Nodes_DistinctOn o, a
+      def visit_Arel_Nodes_DistinctOn o, collector
         raise NotImplementedError, 'DISTINCT ON not implemented for this db'
       end
 
-      def visit_Arel_Nodes_With o, a
-        "WITH #{o.children.map { |x| visit x, a }.join(', ')}"
+      def visit_Arel_Nodes_With o, collector
+        collector << "WITH "
+        inject_join o.children, collector, ', '
       end
 
-      def visit_Arel_Nodes_WithRecursive o, a
-        "WITH RECURSIVE #{o.children.map { |x| visit x, a }.join(', ')}"
+      def visit_Arel_Nodes_WithRecursive o, collector
+        collector << "WITH RECURSIVE "
+        inject_join o.children, collector, ', '
       end
 
-      def visit_Arel_Nodes_Union o, a
-        "( #{visit o.left, a} UNION #{visit o.right, a} )"
+      def visit_Arel_Nodes_Union o, collector
+        collector << "( "
+        infix_value(o, collector, " UNION ") << " )"
       end
 
-      def visit_Arel_Nodes_UnionAll o, a
-        "( #{visit o.left, a} UNION ALL #{visit o.right, a} )"
+      def visit_Arel_Nodes_UnionAll o, collector
+        collector << "( "
+        infix_value(o, collector, " UNION ALL ") << " )"
       end
 
-      def visit_Arel_Nodes_Intersect o, a
-        "( #{visit o.left, a} INTERSECT #{visit o.right, a} )"
+      def visit_Arel_Nodes_Intersect o, collector
+        collector << "( "
+        infix_value(o, collector, " INTERSECT ") << " )"
       end
 
-      def visit_Arel_Nodes_Except o, a
-        "( #{visit o.left, a} EXCEPT #{visit o.right, a} )"
+      def visit_Arel_Nodes_Except o, collector
+        collector << "( "
+        infix_value(o, collector, " EXCEPT ") << " )"
       end
 
-      def visit_Arel_Nodes_NamedWindow o, a
-        "#{quote_column_name o.name} AS #{visit_Arel_Nodes_Window o, a}"
+      def visit_Arel_Nodes_NamedWindow o, collector
+        collector << quote_column_name(o.name)
+        collector << " AS "
+        visit_Arel_Nodes_Window o, collector
       end
 
-      def visit_Arel_Nodes_Window o, a
-        s = [
-          ("ORDER BY #{o.orders.map { |x| visit(x, a) }.join(', ')}" unless o.orders.empty?),
-          (visit o.framing, a if o.framing)
-        ].compact.join ' '
-        "(#{s})"
+      def visit_Arel_Nodes_Window o, collector
+        collector << "("
+
+        if o.partitions.any?
+          collector << "PARTITION BY "
+          collector = inject_join o.partitions, collector, ", "
+        end
+
+        if o.orders.any?
+          collector << ' ' 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 = visit o.framing, collector
+        end
+
+        collector << ")"
       end
 
-      def visit_Arel_Nodes_Rows o, a
+      def visit_Arel_Nodes_Rows o, collector
         if o.expr
-          "ROWS #{visit o.expr, a}"
+          collector << "ROWS "
+          visit o.expr, collector
         else
-          "ROWS"
+          collector << "ROWS"
         end
       end
 
-      def visit_Arel_Nodes_Range o, a
+      def visit_Arel_Nodes_Range o, collector
         if o.expr
-          "RANGE #{visit o.expr, a}"
+          collector << "RANGE "
+          visit o.expr, collector
         else
-          "RANGE"
+          collector << "RANGE"
         end
       end
 
-      def visit_Arel_Nodes_Preceding o, a
-        "#{o.expr ? visit(o.expr, a) : 'UNBOUNDED'} PRECEDING"
+      def visit_Arel_Nodes_Preceding o, collector
+        collector = if o.expr
+                      visit o.expr, collector
+                    else
+                      collector << "UNBOUNDED"
+                    end
+
+        collector << " PRECEDING"
       end
 
-      def visit_Arel_Nodes_Following o, a
-        "#{o.expr ? visit(o.expr, a) : 'UNBOUNDED'} FOLLOWING"
+      def visit_Arel_Nodes_Following o, collector
+        collector = if o.expr
+                      visit o.expr, collector
+                    else
+                      collector << "UNBOUNDED"
+                    end
+
+        collector << " FOLLOWING"
       end
 
-      def visit_Arel_Nodes_CurrentRow o, a
-        "CURRENT ROW"
+      def visit_Arel_Nodes_CurrentRow o, collector
+        collector << "CURRENT ROW"
       end
 
-      def visit_Arel_Nodes_Over o, a
+      def visit_Arel_Nodes_Over o, collector
         case o.right
-          when nil
-            "#{visit o.left, a} OVER ()"
-          when Arel::Nodes::SqlLiteral
-            "#{visit o.left, a} OVER #{visit o.right, a}"
-          when String, Symbol
-            "#{visit o.left, a} OVER #{quote_column_name o.right.to_s}"
-          else
-            "#{visit o.left, a} OVER #{visit o.right, a}"
+        when nil
+          visit(o.left, collector) << " OVER ()"
+        when Arel::Nodes::SqlLiteral
+          infix_value o, collector, " OVER "
+        when String, Symbol
+          visit(o.left, collector) << " OVER #{quote_column_name o.right.to_s}"
+        else
+          infix_value o, collector, " OVER "
         end
       end
 
-      def visit_Arel_Nodes_Having o, a
-        "HAVING #{visit o.expr, a}"
+      def visit_Arel_Nodes_Having o, collector
+        collector << "HAVING "
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Offset o, a
-        "OFFSET #{visit o.expr, a}"
+      def visit_Arel_Nodes_Offset o, collector
+        collector << "OFFSET "
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Limit o, a
-        "LIMIT #{visit o.expr, a}"
+      def visit_Arel_Nodes_Limit o, collector
+        collector << "LIMIT "
+        visit o.expr, collector
       end
 
       # FIXME: this does nothing on most databases, but does on MSSQL
-      def visit_Arel_Nodes_Top o, a
-        ""
+      def visit_Arel_Nodes_Top o, collector
+        collector
       end
 
-      def visit_Arel_Nodes_Lock o, a
-        visit o.expr, a
+      def visit_Arel_Nodes_Lock o, collector
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Grouping o, a
-        "(#{visit o.expr, a})"
+      def visit_Arel_Nodes_Grouping o, collector
+        collector << "("
+        visit(o.expr, collector) << ")"
       end
 
-      def visit_Arel_SelectManager o, a
-        "(#{o.to_sql.rstrip})"
+      def visit_Arel_SelectManager o, collector
+        collector << "(#{o.to_sql.rstrip})"
       end
 
-      def visit_Arel_Nodes_Ascending o, a
-        "#{visit o.expr, a} ASC"
+      def visit_Arel_Nodes_Ascending o, collector
+        visit(o.expr, collector) << " ASC"
       end
 
-      def visit_Arel_Nodes_Descending o, a
-        "#{visit o.expr, a} DESC"
+      def visit_Arel_Nodes_Descending o, collector
+        visit(o.expr, collector) << " DESC"
       end
 
-      def visit_Arel_Nodes_Group o, a
-        visit o.expr, a
+      def visit_Arel_Nodes_Group o, collector
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_NamedFunction o, a
-        "#{o.name}(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a
-        }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_NamedFunction o, collector
+        collector << o.name
+        collector << "("
+        collector << "DISTINCT " if o.distinct
+        collector = inject_join(o.expressions, collector, ", ") << ")"
+        if o.alias
+          collector << " AS "
+          visit o.alias, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_Extract o, collector
+        collector << "EXTRACT(#{o.field.to_s.upcase} FROM "
+        collector = visit o.expr, collector
+        collector << ")"
+        if o.alias
+          collector << " AS "
+          visit o.alias, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_Count o, collector
+        aggregate "COUNT", o, collector
+      end
+
+      def visit_Arel_Nodes_Sum o, collector
+        aggregate "SUM", o, collector
       end
 
-      def visit_Arel_Nodes_Extract o, a
-        "EXTRACT(#{o.field.to_s.upcase} FROM #{visit o.expr, a})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Max o, collector
+        aggregate "MAX", o, collector
       end
 
-      def visit_Arel_Nodes_Count o, a
-        "COUNT(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a
-        }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Min o, collector
+        aggregate "MIN", o, collector
       end
 
-      def visit_Arel_Nodes_Sum o, a
-        "SUM(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Avg o, collector
+        aggregate "AVG", o, collector
       end
 
-      def visit_Arel_Nodes_Max o, a
-        "MAX(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_TableAlias o, collector
+        collector = visit o.relation, collector
+        collector << " "
+        collector << quote_table_name(o.name)
       end
 
-      def visit_Arel_Nodes_Min o, a
-        "MIN(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_Between o, collector
+        collector = visit o.left, collector
+        collector << " BETWEEN "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_Avg o, a
-        "AVG(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
+      def visit_Arel_Nodes_GreaterThanOrEqual o, collector
+        collector = visit o.left, collector
+        collector << " >= "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_TableAlias o, a
-        "#{visit o.relation, a} #{quote_table_name o.name}"
+      def visit_Arel_Nodes_GreaterThan o, collector
+        collector = visit o.left, collector
+        collector << " > "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_Between o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} BETWEEN #{visit o.right, a}"
+      def visit_Arel_Nodes_LessThanOrEqual o, collector
+        collector = visit o.left, collector
+        collector << " <= "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_GreaterThanOrEqual o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} >= #{visit o.right, a}"
+      def visit_Arel_Nodes_LessThan o, collector
+        collector = visit o.left, collector
+        collector << " < "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_GreaterThan o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} > #{visit o.right, a}"
+      def visit_Arel_Nodes_Matches o, collector
+        collector = visit o.left, collector
+        collector << " LIKE "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_LessThanOrEqual o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} <= #{visit o.right, a}"
+      def visit_Arel_Nodes_DoesNotMatch o, collector
+        collector = visit o.left, collector
+        collector << " NOT LIKE "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_LessThan o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} < #{visit o.right, a}"
+      def visit_Arel_Nodes_JoinSource o, collector
+        if o.left
+          collector = visit o.left, collector
+        end
+        if o.right.any?
+          collector << " " if o.left
+          collector = inject_join o.right, collector, ' '
+        end
+        collector
       end
 
-      def visit_Arel_Nodes_Matches o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} LIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_Regexp o, collector
+        raise NotImplementedError, '~ not implemented for this db'
       end
 
-      def visit_Arel_Nodes_DoesNotMatch o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} NOT LIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_NotRegexp o, collector
+        raise NotImplementedError, '!~ not implemented for this db'
       end
 
-      def visit_Arel_Nodes_JoinSource o, a
-        [
-          (visit(o.left, a) if o.left),
-          o.right.map { |j| visit j, a }.join(' ')
-        ].compact.join ' '
+      def visit_Arel_Nodes_StringJoin o, collector
+        visit o.left, collector
       end
 
-      def visit_Arel_Nodes_StringJoin o, a
-        visit o.left, a
+      def visit_Arel_Nodes_FullOuterJoin o
+        "FULL OUTER JOIN #{visit o.left} #{visit o.right}"
       end
 
-      def visit_Arel_Nodes_OuterJoin o, a
-        "LEFT OUTER JOIN #{visit o.left, a} #{visit o.right, a}"
+      def visit_Arel_Nodes_OuterJoin o, collector
+        collector << "LEFT OUTER JOIN "
+        collector = visit o.left, collector
+        collector << " "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_InnerJoin o, a
-        s = "INNER JOIN #{visit o.left, a}"
+      def visit_Arel_Nodes_RightOuterJoin o
+        "RIGHT OUTER JOIN #{visit o.left} #{visit o.right}"
+      end
+
+      def visit_Arel_Nodes_InnerJoin o, collector
+        collector << "INNER JOIN "
+        collector = visit o.left, collector
         if o.right
-          s << SPACE
-          s << visit(o.right, a)
+          collector << SPACE
+          visit(o.right, collector)
+        else
+          collector
         end
-        s
       end
 
-      def visit_Arel_Nodes_On o, a
-        "ON #{visit o.expr, a}"
+      def visit_Arel_Nodes_On o, collector
+        collector << "ON "
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Not o, a
-        "NOT (#{visit o.expr, a})"
+      def visit_Arel_Nodes_Not o, collector
+        collector << "NOT ("
+        visit(o.expr, collector) << ")"
       end
 
-      def visit_Arel_Table o, a
+      def visit_Arel_Table o, collector
         if o.table_alias
-          "#{quote_table_name o.name} #{quote_table_name o.table_alias}"
+          collector << "#{quote_table_name o.name} #{quote_table_name o.table_alias}"
         else
-          quote_table_name o.name
+          collector << quote_table_name(o.name)
         end
       end
 
-      def visit_Arel_Nodes_In o, a
+      def visit_Arel_Nodes_In o, collector
         if Array === o.right && o.right.empty?
-          '1=0'
+          collector << '1=0'
         else
-          a = o.left if Arel::Attributes::Attribute === o.left
-          "#{visit o.left, a} IN (#{visit o.right, a})"
+          collector = visit o.left, collector
+          collector << " IN ("
+          visit(o.right, collector) << ")"
         end
       end
 
-      def visit_Arel_Nodes_NotIn o, a
+      def visit_Arel_Nodes_NotIn o, collector
         if Array === o.right && o.right.empty?
-          '1=1'
+          collector << '1=1'
         else
-          a = o.left if Arel::Attributes::Attribute === o.left
-          "#{visit o.left, a} NOT IN (#{visit o.right, a})"
+          collector = visit o.left, collector
+          collector << " NOT IN ("
+          collector = visit o.right, collector
+          collector << ")"
         end
       end
 
-      def visit_Arel_Nodes_And o, a
-        o.children.map { |x| visit x, a }.join ' AND '
+      def visit_Arel_Nodes_And o, collector
+        inject_join o.children, collector, " AND "
       end
 
-      def visit_Arel_Nodes_Or o, a
-        "#{visit o.left, a} OR #{visit o.right, a}"
+      def visit_Arel_Nodes_Or o, collector
+        collector = visit o.left, collector
+        collector << " OR "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_Assignment o, a
-        right = quote(o.right, column_for(o.left))
-        "#{visit o.left, a} = #{right}"
+      def visit_Arel_Nodes_Assignment o, collector
+        case o.right
+        when Arel::Nodes::UnqualifiedColumn, Arel::Attributes::Attribute, Arel::Nodes::BindParam
+          collector = visit o.left, collector
+          collector << " = "
+          visit o.right, collector
+        else
+          collector = visit o.left, collector
+          collector << " = "
+          collector << quote(o.right, column_for(o.left)).to_s
+        end
       end
 
-      def visit_Arel_Nodes_Equality o, a
+      def visit_Arel_Nodes_Equality o, collector
         right = o.right
 
-        a = o.left if Arel::Attributes::Attribute === o.left
+        collector = visit o.left, collector
+
         if right.nil?
-          "#{visit o.left, a} IS NULL"
+          collector << " IS NULL"
         else
-          "#{visit o.left, a} = #{visit right, a}"
+          collector << " = "
+          visit right, collector
         end
       end
 
-      def visit_Arel_Nodes_NotEqual o, a
+      def visit_Arel_Nodes_NotEqual o, collector
         right = o.right
 
-        a = o.left if Arel::Attributes::Attribute === o.left
+        collector = visit o.left, collector
+
         if right.nil?
-          "#{visit o.left, a} IS NOT NULL"
+          collector << " IS NOT NULL"
         else
-          "#{visit o.left, a} != #{visit right, a}"
+          collector << " != "
+          visit right, collector
         end
       end
 
-      def visit_Arel_Nodes_As o, a
-        "#{visit o.left, a} AS #{visit o.right, a}"
+      def visit_Arel_Nodes_As o, collector
+        collector = visit o.left, collector
+        collector << " AS "
+        visit o.right, collector
       end
 
-      def visit_Arel_Nodes_UnqualifiedColumn o, a
-        "#{quote_column_name o.name}"
+      def visit_Arel_Nodes_UnqualifiedColumn o, collector
+        collector << "#{quote_column_name o.name}"
+        collector
       end
 
-      def visit_Arel_Attributes_Attribute o, a
+      def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
-        "#{quote_table_name join_name}.#{quote_column_name o.name}"
+        collector << "#{quote_table_name join_name}.#{quote_column_name o.name}"
       end
       alias :visit_Arel_Attributes_Integer :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Float :visit_Arel_Attributes_Attribute
@@ -546,11 +708,13 @@ module Arel
       alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute
 
-      def literal o, a; o end
+      def literal o, collector; collector << o.to_s; end
+
+      def visit_Arel_Nodes_BindParam o, collector
+        collector.add_bind o
+      end
 
-      alias :visit_Arel_Nodes_BindParam  :literal
       alias :visit_Arel_Nodes_SqlLiteral :literal
-      alias :visit_Arel_SqlLiteral       :literal # This is deprecated
       alias :visit_Bignum                :literal
       alias :visit_Fixnum                :literal
 
@@ -558,23 +722,29 @@ module Arel
         quote(o, column_for(a))
       end
 
-      alias :visit_ActiveSupport_Multibyte_Chars :quoted
-      alias :visit_ActiveSupport_StringInquirer  :quoted
-      alias :visit_BigDecimal                    :quoted
-      alias :visit_Class                         :quoted
-      alias :visit_Date                          :quoted
-      alias :visit_DateTime                      :quoted
-      alias :visit_FalseClass                    :quoted
-      alias :visit_Float                         :quoted
-      alias :visit_Hash                          :quoted
-      alias :visit_NilClass                      :quoted
-      alias :visit_String                        :quoted
-      alias :visit_Symbol                        :quoted
-      alias :visit_Time                          :quoted
-      alias :visit_TrueClass                     :quoted
+      def unsupported o, collector
+        raise "unsupported: #{o.class.name}"
+      end
+
+      alias :visit_ActiveSupport_Multibyte_Chars :unsupported
+      alias :visit_ActiveSupport_StringInquirer  :unsupported
+      alias :visit_BigDecimal                    :unsupported
+      alias :visit_Class                         :unsupported
+      alias :visit_Date                          :unsupported
+      alias :visit_DateTime                      :unsupported
+      alias :visit_FalseClass                    :unsupported
+      alias :visit_Float                         :unsupported
+      alias :visit_Hash                          :unsupported
+      alias :visit_NilClass                      :unsupported
+      alias :visit_String                        :unsupported
+      alias :visit_Symbol                        :unsupported
+      alias :visit_Time                          :unsupported
+      alias :visit_TrueClass                     :unsupported
 
-      def visit_Arel_Nodes_InfixOperation o, a
-        "#{visit o.left, a} #{o.operator} #{visit o.right, a}"
+      def visit_Arel_Nodes_InfixOperation o, collector
+        collector = visit o.left, collector
+        collector << " #{o.operator} "
+        visit o.right, collector
       end
 
       alias :visit_Arel_Nodes_Addition       :visit_Arel_Nodes_InfixOperation
@@ -582,8 +752,8 @@ module Arel
       alias :visit_Arel_Nodes_Multiplication :visit_Arel_Nodes_InfixOperation
       alias :visit_Arel_Nodes_Division       :visit_Arel_Nodes_InfixOperation
 
-      def visit_Array o, a
-        o.map { |x| visit x, a }.join(', ')
+      def visit_Array o, collector
+        inject_join o, collector, ", "
       end
 
       def quote value, column = nil
@@ -599,6 +769,43 @@ module Arel
       def quote_column_name name
         @quoted_columns[name] ||= Arel::Nodes::SqlLiteral === name ? name : @connection.quote_column_name(name)
       end
+
+      def maybe_visit thing, collector
+        return collector unless thing
+        collector << " "
+        visit thing, collector
+      end
+
+      def inject_join list, collector, join_str
+        len = list.length - 1
+        list.each_with_index.inject(collector) { |c, (x,i)|
+          if i == len
+            visit x, c
+          else
+            visit(x, c) << join_str
+          end
+        }
+      end
+
+      def infix_value o, collector, value
+        collector = visit o.left, collector
+        collector << value
+        visit o.right, collector
+      end
+
+      def aggregate name, o, collector
+        collector << "#{name}("
+        if o.distinct
+          collector << "DISTINCT "
+        end
+        collector = inject_join(o.expressions, collector, ", ") << ")"
+        if o.alias
+          collector << " AS "
+          visit o.alias, collector
+        else
+          collector
+        end
+      end
     end
   end
 end