arel 4.0.0 → 4.0.1

data/lib/arel/visitors/order_clauses.rb

@@ -3,8 +3,8 @@ module Arel
     class OrderClauses < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_SelectStatement o
-        o.orders.map { |x| visit x }
+      def visit_Arel_Nodes_SelectStatement o, a
+        o.orders.map { |x| visit x, a }
       end
     end
   end

data/lib/arel/visitors/postgresql.rb

@@ -3,16 +3,16 @@ module Arel
     class PostgreSQL < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_Matches o
-        "#{visit o.left} ILIKE #{visit o.right}"
+      def visit_Arel_Nodes_Matches o, a
+        "#{visit o.left, a} ILIKE #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_DoesNotMatch o
-        "#{visit o.left} NOT ILIKE #{visit o.right}"
+      def visit_Arel_Nodes_DoesNotMatch o, a
+        "#{visit o.left, a} NOT ILIKE #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_DistinctOn o
-        "DISTINCT ON ( #{visit o.expr} )"
+      def visit_Arel_Nodes_DistinctOn o, a
+        "DISTINCT ON ( #{visit o.expr, a} )"
       end
     end
   end

data/lib/arel/visitors/sqlite.rb

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

data/lib/arel/visitors/to_sql.rb

@@ -53,23 +53,16 @@ module Arel
 
       DISTINCT = 'DISTINCT'   # :nodoc:
 
-      attr_accessor :last_column
-
       def initialize connection
         @connection     = connection
         @schema_cache   = connection.schema_cache
         @quoted_tables  = {}
         @quoted_columns = {}
-        @last_column    = nil
-      end
-
-      def accept object
-        self.last_column = nil
-        super
       end
 
       private
-      def visit_Arel_Nodes_DeleteStatement o
+
+      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?)
@@ -88,7 +81,7 @@ module Arel
         stmt
       end
 
-      def visit_Arel_Nodes_UpdateStatement o
+      def visit_Arel_Nodes_UpdateStatement o, a
         if o.orders.empty? && o.limit.nil?
           wheres = o.wheres
         else
@@ -97,7 +90,7 @@ module Arel
             warn(<<-eowarn) if $VERBOSE
 (#{caller.first}) Using UpdateManager without setting UpdateManager#key is
 deprecated and support will be removed in Arel 4.0.0.  Please set the primary
-key on UpdateManager using UpdateManager#key=
+key on UpdateManager using UpdateManager#key= '#{key.inspect}'
             eowarn
             key = o.relation.primary_key
           end
@@ -106,34 +99,34 @@ key on UpdateManager using UpdateManager#key=
         end
 
         [
-          "UPDATE #{visit o.relation}",
-          ("SET #{o.values.map { |value| visit value }.join ', '}" unless o.values.empty?),
-          ("WHERE #{wheres.map { |x| visit x }.join ' AND '}" unless wheres.empty?),
+          "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 ' '
       end
 
-      def visit_Arel_Nodes_InsertStatement o
+      def visit_Arel_Nodes_InsertStatement o, a
         [
-          "INSERT INTO #{visit o.relation}",
+          "INSERT INTO #{visit o.relation, a}",
 
           ("(#{o.columns.map { |x|
           quote_column_name x.name
         }.join ', '})" unless o.columns.empty?),
 
-          (visit o.values if o.values),
+          (visit o.values, a if o.values),
         ].compact.join ' '
       end
 
-      def visit_Arel_Nodes_Exists o
-        "EXISTS (#{visit o.expressions})#{
-          o.alias ? " AS #{visit o.alias}" : ''}"
+      def visit_Arel_Nodes_Exists o, a
+        "EXISTS (#{visit o.expressions, a})#{
+          o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_True o
+      def visit_Arel_Nodes_True o, a
         "TRUE"
       end
 
-      def visit_Arel_Nodes_False o
+      def visit_Arel_Nodes_False o, a
         "FALSE"
       end
 
@@ -142,6 +135,7 @@ key on UpdateManager using UpdateManager#key=
       end
 
       def column_for attr
+        return unless attr
         name    = attr.name.to_s
         table   = attr.relation.table_name
 
@@ -154,66 +148,66 @@ key on UpdateManager using UpdateManager#key=
         @schema_cache.columns_hash(table)
       end
 
-      def visit_Arel_Nodes_Values o
+      def visit_Arel_Nodes_Values o, a
         "VALUES (#{o.expressions.zip(o.columns).map { |value, attr|
           if Nodes::SqlLiteral === value
-            visit value
+            visit value, a
           else
             quote(value, attr && column_for(attr))
           end
         }.join ', '})"
       end
 
-      def visit_Arel_Nodes_SelectStatement o
+      def visit_Arel_Nodes_SelectStatement o, a
         str = ''
 
         if o.with
-          str << visit(o.with)
+          str << visit(o.with, a)
           str << SPACE
         end
 
-        o.cores.each { |x| str << visit_Arel_Nodes_SelectCore(x) }
+        o.cores.each { |x| str << visit_Arel_Nodes_SelectCore(x, a) }
 
         unless o.orders.empty?
           str << SPACE
           str << ORDER_BY
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
-            str << visit(x)
+            str << visit(x, a)
             str << COMMA unless len == i
           }
         end
 
-        str << " #{visit(o.limit)}" if o.limit
-        str << " #{visit(o.offset)}" if o.offset
-        str << " #{visit(o.lock)}" if o.lock
+        str << " #{visit(o.limit, a)}" if o.limit
+        str << " #{visit(o.offset, a)}" if o.offset
+        str << " #{visit(o.lock, a)}" if o.lock
 
         str.strip!
         str
       end
 
-      def visit_Arel_Nodes_SelectCore o
+      def visit_Arel_Nodes_SelectCore o, a
         str = "SELECT"
 
-        str << " #{visit(o.top)}"            if o.top
-        str << " #{visit(o.set_quantifier)}" if o.set_quantifier
+        str << " #{visit(o.top, a)}"            if o.top
+        str << " #{visit(o.set_quantifier, a)}" if o.set_quantifier
 
         unless o.projections.empty?
           str << SPACE
           len = o.projections.length - 1
           o.projections.each_with_index do |x, i|
-            str << visit(x)
+            str << visit(x, a)
             str << COMMA unless len == i
           end
         end
 
-        str << " FROM #{visit(o.source)}" if o.source && !o.source.empty?
+        str << " FROM #{visit(o.source, a)}" if o.source && !o.source.empty?
 
         unless o.wheres.empty?
           str << WHERE
           len = o.wheres.length - 1
           o.wheres.each_with_index do |x, i|
-            str << visit(x)
+            str << visit(x, a)
             str << AND unless len == i
           end
         end
@@ -222,18 +216,18 @@ key on UpdateManager using UpdateManager#key=
           str << GROUP_BY
           len = o.groups.length - 1
           o.groups.each_with_index do |x, i|
-            str << visit(x)
+            str << visit(x, a)
             str << COMMA unless len == i
           end
         end
 
-        str << " #{visit(o.having)}" if o.having
+        str << " #{visit(o.having, a)}" if o.having
 
         unless o.windows.empty?
           str << WINDOW
           len = o.windows.length - 1
           o.windows.each_with_index do |x, i|
-            str << visit(x)
+            str << visit(x, a)
             str << COMMA unless len == i
           end
         end
@@ -241,237 +235,244 @@ key on UpdateManager using UpdateManager#key=
         str
       end
 
-      def visit_Arel_Nodes_Bin o
-        visit o.expr
+      def visit_Arel_Nodes_Bin o, a
+        visit o.expr, a
       end
 
-      def visit_Arel_Nodes_Distinct o
+      def visit_Arel_Nodes_Distinct o, a
         DISTINCT
       end
 
-      def visit_Arel_Nodes_DistinctOn o
+      def visit_Arel_Nodes_DistinctOn o, a
         raise NotImplementedError, 'DISTINCT ON not implemented for this db'
       end
 
-      def visit_Arel_Nodes_With o
-        "WITH #{o.children.map { |x| visit x }.join(', ')}"
+      def visit_Arel_Nodes_With o, a
+        "WITH #{o.children.map { |x| visit x, a }.join(', ')}"
       end
 
-      def visit_Arel_Nodes_WithRecursive o
-        "WITH RECURSIVE #{o.children.map { |x| visit x }.join(', ')}"
+      def visit_Arel_Nodes_WithRecursive o, a
+        "WITH RECURSIVE #{o.children.map { |x| visit x, a }.join(', ')}"
       end
 
-      def visit_Arel_Nodes_Union o
-        "( #{visit o.left} UNION #{visit o.right} )"
+      def visit_Arel_Nodes_Union o, a
+        "( #{visit o.left, a} UNION #{visit o.right, a} )"
       end
 
-      def visit_Arel_Nodes_UnionAll o
-        "( #{visit o.left} UNION ALL #{visit o.right} )"
+      def visit_Arel_Nodes_UnionAll o, a
+        "( #{visit o.left, a} UNION ALL #{visit o.right, a} )"
       end
 
-      def visit_Arel_Nodes_Intersect o
-        "( #{visit o.left} INTERSECT #{visit o.right} )"
+      def visit_Arel_Nodes_Intersect o, a
+        "( #{visit o.left, a} INTERSECT #{visit o.right, a} )"
       end
 
-      def visit_Arel_Nodes_Except o
-        "( #{visit o.left} EXCEPT #{visit o.right} )"
+      def visit_Arel_Nodes_Except o, a
+        "( #{visit o.left, a} EXCEPT #{visit o.right, a} )"
       end
 
-      def visit_Arel_Nodes_NamedWindow o
-        "#{quote_column_name o.name} AS #{visit_Arel_Nodes_Window o}"
+      def visit_Arel_Nodes_NamedWindow o, a
+        "#{quote_column_name o.name} AS #{visit_Arel_Nodes_Window o, a}"
       end
 
-      def visit_Arel_Nodes_Window o
+      def visit_Arel_Nodes_Window o, a
         s = [
-          ("ORDER BY #{o.orders.map { |x| visit(x) }.join(', ')}" unless o.orders.empty?),
-          (visit o.framing if o.framing)
+          ("ORDER BY #{o.orders.map { |x| visit(x, a) }.join(', ')}" unless o.orders.empty?),
+          (visit o.framing, a if o.framing)
         ].compact.join ' '
         "(#{s})"
       end
 
-      def visit_Arel_Nodes_Rows o
+      def visit_Arel_Nodes_Rows o, a
         if o.expr
-          "ROWS #{visit o.expr}"
+          "ROWS #{visit o.expr, a}"
         else
           "ROWS"
         end
       end
 
-      def visit_Arel_Nodes_Range o
+      def visit_Arel_Nodes_Range o, a
         if o.expr
-          "RANGE #{visit o.expr}"
+          "RANGE #{visit o.expr, a}"
         else
           "RANGE"
         end
       end
 
-      def visit_Arel_Nodes_Preceding o
-        "#{o.expr ? visit(o.expr) : 'UNBOUNDED'} PRECEDING"
+      def visit_Arel_Nodes_Preceding o, a
+        "#{o.expr ? visit(o.expr, a) : 'UNBOUNDED'} PRECEDING"
       end
 
-      def visit_Arel_Nodes_Following o
-        "#{o.expr ? visit(o.expr) : 'UNBOUNDED'} FOLLOWING"
+      def visit_Arel_Nodes_Following o, a
+        "#{o.expr ? visit(o.expr, a) : 'UNBOUNDED'} FOLLOWING"
       end
 
-      def visit_Arel_Nodes_CurrentRow o
+      def visit_Arel_Nodes_CurrentRow o, a
         "CURRENT ROW"
       end
 
-      def visit_Arel_Nodes_Over o
+      def visit_Arel_Nodes_Over o, a
         case o.right
           when nil
-            "#{visit o.left} OVER ()"
+            "#{visit o.left, a} OVER ()"
           when Arel::Nodes::SqlLiteral
-            "#{visit o.left} OVER #{visit o.right}"
+            "#{visit o.left, a} OVER #{visit o.right, a}"
           when String, Symbol
-            "#{visit o.left} OVER #{quote_column_name o.right.to_s}"
+            "#{visit o.left, a} OVER #{quote_column_name o.right.to_s}"
           else
-            "#{visit o.left} OVER #{visit o.right}"
+            "#{visit o.left, a} OVER #{visit o.right, a}"
         end
       end
 
-      def visit_Arel_Nodes_Having o
-        "HAVING #{visit o.expr}"
+      def visit_Arel_Nodes_Having o, a
+        "HAVING #{visit o.expr, a}"
       end
 
-      def visit_Arel_Nodes_Offset o
-        "OFFSET #{visit o.expr}"
+      def visit_Arel_Nodes_Offset o, a
+        "OFFSET #{visit o.expr, a}"
       end
 
-      def visit_Arel_Nodes_Limit o
-        "LIMIT #{visit o.expr}"
+      def visit_Arel_Nodes_Limit o, a
+        "LIMIT #{visit o.expr, a}"
       end
 
       # FIXME: this does nothing on most databases, but does on MSSQL
-      def visit_Arel_Nodes_Top o
+      def visit_Arel_Nodes_Top o, a
         ""
       end
 
-      def visit_Arel_Nodes_Lock o
-        visit o.expr
+      def visit_Arel_Nodes_Lock o, a
+        visit o.expr, a
       end
 
-      def visit_Arel_Nodes_Grouping o
-        "(#{visit o.expr})"
+      def visit_Arel_Nodes_Grouping o, a
+        "(#{visit o.expr, a})"
       end
 
-      def visit_Arel_SelectManager o
+      def visit_Arel_SelectManager o, a
         "(#{o.to_sql.rstrip})"
       end
 
-      def visit_Arel_Nodes_Ascending o
-        "#{visit o.expr} ASC"
+      def visit_Arel_Nodes_Ascending o, a
+        "#{visit o.expr, a} ASC"
       end
 
-      def visit_Arel_Nodes_Descending o
-        "#{visit o.expr} DESC"
+      def visit_Arel_Nodes_Descending o, a
+        "#{visit o.expr, a} DESC"
       end
 
-      def visit_Arel_Nodes_Group o
-        visit o.expr
+      def visit_Arel_Nodes_Group o, a
+        visit o.expr, a
       end
 
-      def visit_Arel_Nodes_NamedFunction o
+      def visit_Arel_Nodes_NamedFunction o, a
         "#{o.name}(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x
-        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+          visit x, a
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_Extract o
-        "EXTRACT(#{o.field.to_s.upcase} FROM #{visit o.expr})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      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}" : ''}"
       end
 
-      def visit_Arel_Nodes_Count o
+      def visit_Arel_Nodes_Count o, a
         "COUNT(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x
-        }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+          visit x, a
+        }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_Sum o
+      def visit_Arel_Nodes_Sum o, a
         "SUM(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_Max o
+      def visit_Arel_Nodes_Max o, a
         "MAX(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_Min o
+      def visit_Arel_Nodes_Min o, a
         "MIN(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_Avg o
+      def visit_Arel_Nodes_Avg o, a
         "AVG(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
-          visit x }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
+          visit x, a }.join(', ')})#{o.alias ? " AS #{visit o.alias, a}" : ''}"
       end
 
-      def visit_Arel_Nodes_TableAlias o
-        "#{visit o.relation} #{quote_table_name o.name}"
+      def visit_Arel_Nodes_TableAlias o, a
+        "#{visit o.relation, a} #{quote_table_name o.name}"
       end
 
-      def visit_Arel_Nodes_Between o
-        "#{visit o.left} BETWEEN #{visit o.right}"
+      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}"
       end
 
-      def visit_Arel_Nodes_GreaterThanOrEqual o
-        "#{visit o.left} >= #{visit o.right}"
+      def visit_Arel_Nodes_GreaterThanOrEqual o, a
+        a = o.left if Arel::Attributes::Attribute === o.left
+        "#{visit o.left, a} >= #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_GreaterThan o
-        "#{visit o.left} > #{visit o.right}"
+      def visit_Arel_Nodes_GreaterThan o, a
+        a = o.left if Arel::Attributes::Attribute === o.left
+        "#{visit o.left, a} > #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_LessThanOrEqual o
-        "#{visit o.left} <= #{visit o.right}"
+      def visit_Arel_Nodes_LessThanOrEqual o, a
+        a = o.left if Arel::Attributes::Attribute === o.left
+        "#{visit o.left, a} <= #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_LessThan o
-        "#{visit o.left} < #{visit o.right}"
+      def visit_Arel_Nodes_LessThan o, a
+        a = o.left if Arel::Attributes::Attribute === o.left
+        "#{visit o.left, a} < #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_Matches o
-        "#{visit o.left} LIKE #{visit o.right}"
+      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}"
       end
 
-      def visit_Arel_Nodes_DoesNotMatch o
-        "#{visit o.left} NOT LIKE #{visit o.right}"
+      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}"
       end
 
-      def visit_Arel_Nodes_JoinSource o
+      def visit_Arel_Nodes_JoinSource o, a
         [
-          (visit(o.left) if o.left),
-          o.right.map { |j| visit j }.join(' ')
+          (visit(o.left, a) if o.left),
+          o.right.map { |j| visit j, a }.join(' ')
         ].compact.join ' '
       end
 
-      def visit_Arel_Nodes_StringJoin o
-        visit o.left
+      def visit_Arel_Nodes_StringJoin o, a
+        visit o.left, a
       end
 
-      def visit_Arel_Nodes_OuterJoin o
-        "LEFT OUTER JOIN #{visit o.left} #{visit o.right}"
+      def visit_Arel_Nodes_OuterJoin o, a
+        "LEFT OUTER JOIN #{visit o.left, a} #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_InnerJoin o
-        s = "INNER JOIN #{visit o.left}"
+      def visit_Arel_Nodes_InnerJoin o, a
+        s = "INNER JOIN #{visit o.left, a}"
         if o.right
           s << SPACE
-          s << visit(o.right)
+          s << visit(o.right, a)
         end
         s
       end
 
-      def visit_Arel_Nodes_On o
-        "ON #{visit o.expr}"
+      def visit_Arel_Nodes_On o, a
+        "ON #{visit o.expr, a}"
       end
 
-      def visit_Arel_Nodes_Not o
-        "NOT (#{visit o.expr})"
+      def visit_Arel_Nodes_Not o, a
+        "NOT (#{visit o.expr, a})"
       end
 
-      def visit_Arel_Table o
+      def visit_Arel_Table o, a
         if o.table_alias
           "#{quote_table_name o.name} #{quote_table_name o.table_alias}"
         else
@@ -479,65 +480,68 @@ key on UpdateManager using UpdateManager#key=
         end
       end
 
-      def visit_Arel_Nodes_In o
+      def visit_Arel_Nodes_In o, a
         if Array === o.right && o.right.empty?
           '1=0'
         else
-          "#{visit o.left} IN (#{visit o.right})"
+          a = o.left if Arel::Attributes::Attribute === o.left
+          "#{visit o.left, a} IN (#{visit o.right, a})"
         end
       end
 
-      def visit_Arel_Nodes_NotIn o
+      def visit_Arel_Nodes_NotIn o, a
         if Array === o.right && o.right.empty?
           '1=1'
         else
-          "#{visit o.left} NOT IN (#{visit o.right})"
+          a = o.left if Arel::Attributes::Attribute === o.left
+          "#{visit o.left, a} NOT IN (#{visit o.right, a})"
         end
       end
 
-      def visit_Arel_Nodes_And o
-        o.children.map { |x| visit x }.join ' AND '
+      def visit_Arel_Nodes_And o, a
+        o.children.map { |x| visit x, a }.join ' AND '
       end
 
-      def visit_Arel_Nodes_Or o
-        "#{visit o.left} OR #{visit o.right}"
+      def visit_Arel_Nodes_Or o, a
+        "#{visit o.left, a} OR #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_Assignment o
+      def visit_Arel_Nodes_Assignment o, a
         right = quote(o.right, column_for(o.left))
-        "#{visit o.left} = #{right}"
+        "#{visit o.left, a} = #{right}"
       end
 
-      def visit_Arel_Nodes_Equality o
+      def visit_Arel_Nodes_Equality o, a
         right = o.right
 
+        a = o.left if Arel::Attributes::Attribute === o.left
         if right.nil?
-          "#{visit o.left} IS NULL"
+          "#{visit o.left, a} IS NULL"
         else
-          "#{visit o.left} = #{visit right}"
+          "#{visit o.left, a} = #{visit right, a}"
         end
       end
 
-      def visit_Arel_Nodes_NotEqual o
+      def visit_Arel_Nodes_NotEqual o, a
         right = o.right
 
+        a = o.left if Arel::Attributes::Attribute === o.left
         if right.nil?
-          "#{visit o.left} IS NOT NULL"
+          "#{visit o.left, a} IS NOT NULL"
         else
-          "#{visit o.left} != #{visit right}"
+          "#{visit o.left, a} != #{visit right, a}"
         end
       end
 
-      def visit_Arel_Nodes_As o
-        "#{visit o.left} AS #{visit o.right}"
+      def visit_Arel_Nodes_As o, a
+        "#{visit o.left, a} AS #{visit o.right, a}"
       end
 
-      def visit_Arel_Nodes_UnqualifiedColumn o
+      def visit_Arel_Nodes_UnqualifiedColumn o, a
         "#{quote_column_name o.name}"
       end
 
-      def visit_Arel_Attributes_Attribute o
-        self.last_column = column_for o
+      def visit_Arel_Attributes_Attribute o, a
         join_name = o.relation.table_alias || o.relation.name
         "#{quote_table_name join_name}.#{quote_column_name o.name}"
       end
@@ -548,7 +552,7 @@ key on UpdateManager using UpdateManager#key=
       alias :visit_Arel_Attributes_Time :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Boolean :visit_Arel_Attributes_Attribute
 
-      def literal o; o end
+      def literal o, a; o end
 
       alias :visit_Arel_Nodes_BindParam  :literal
       alias :visit_Arel_Nodes_SqlLiteral :literal
@@ -556,8 +560,8 @@ key on UpdateManager using UpdateManager#key=
       alias :visit_Bignum                :literal
       alias :visit_Fixnum                :literal
 
-      def quoted o
-        quote(o, last_column)
+      def quoted o, a
+        quote(o, column_for(a))
       end
 
       alias :visit_ActiveSupport_Multibyte_Chars :quoted
@@ -575,8 +579,8 @@ key on UpdateManager using UpdateManager#key=
       alias :visit_Time                          :quoted
       alias :visit_TrueClass                     :quoted
 
-      def visit_Arel_Nodes_InfixOperation o
-        "#{visit o.left} #{o.operator} #{visit o.right}"
+      def visit_Arel_Nodes_InfixOperation o, a
+        "#{visit o.left, a} #{o.operator} #{visit o.right, a}"
       end
 
       alias :visit_Arel_Nodes_Addition       :visit_Arel_Nodes_InfixOperation
@@ -584,8 +588,8 @@ key on UpdateManager using UpdateManager#key=
       alias :visit_Arel_Nodes_Multiplication :visit_Arel_Nodes_InfixOperation
       alias :visit_Arel_Nodes_Division       :visit_Arel_Nodes_InfixOperation
 
-      def visit_Array o
-        o.map { |x| visit x }.join(', ')
+      def visit_Array o, a
+        o.map { |x| visit x, a }.join(', ')
       end
 
       def quote value, column = nil