activerecord 6.0.0.beta3 → 6.0.2.rc2

data/lib/arel/insert_manager.rb

@@ -33,13 +33,13 @@ module Arel # :nodoc: all
           @ast.columns << column
           values << value
         end
-        @ast.values = create_values values, @ast.columns
+        @ast.values = create_values(values)
       end
       self
     end
 
-    def create_values(values, columns)
-      Nodes::Values.new values, columns
+    def create_values(values)
+      Nodes::ValuesList.new([values])
     end
 
     def create_values_list(rows)

data/lib/arel/nodes.rb

@@ -45,7 +45,6 @@ require "arel/nodes/and"
 require "arel/nodes/function"
 require "arel/nodes/count"
 require "arel/nodes/extract"
-require "arel/nodes/values"
 require "arel/nodes/values_list"
 require "arel/nodes/named_function"
 
@@ -62,6 +61,8 @@ require "arel/nodes/outer_join"
 require "arel/nodes/right_outer_join"
 require "arel/nodes/string_join"
 
+require "arel/nodes/comment"
+
 require "arel/nodes/sql_literal"
 
 require "arel/nodes/casted"

data/lib/arel/nodes/comment.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Nodes
+    class Comment < Arel::Nodes::Node
+      attr_reader :values
+
+      def initialize(values)
+        super()
+        @values = values
+      end
+
+      def initialize_copy(other)
+        super
+        @values = @values.clone
+      end
+
+      def hash
+        [@values].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          self.values == other.values
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/arel/nodes/select_core.rb

@@ -3,20 +3,22 @@
 module Arel # :nodoc: all
   module Nodes
     class SelectCore < Arel::Nodes::Node
-      attr_accessor :projections, :wheres, :groups, :windows
-      attr_accessor :havings, :source, :set_quantifier
+      attr_accessor :projections, :wheres, :groups, :windows, :comment
+      attr_accessor :havings, :source, :set_quantifier, :optimizer_hints
 
       def initialize
         super()
-        @source         = JoinSource.new nil
+        @source = JoinSource.new nil
 
         # https://ronsavage.github.io/SQL/sql-92.bnf.html#set%20quantifier
-        @set_quantifier = nil
-        @projections    = []
-        @wheres         = []
-        @groups         = []
-        @havings        = []
-        @windows        = []
+        @set_quantifier  = nil
+        @optimizer_hints = nil
+        @projections     = []
+        @wheres          = []
+        @groups          = []
+        @havings         = []
+        @windows         = []
+        @comment         = nil
       end
 
       def from
@@ -42,8 +44,8 @@ module Arel # :nodoc: all
 
       def hash
         [
-          @source, @set_quantifier, @projections,
-          @wheres, @groups, @havings, @windows
+          @source, @set_quantifier, @projections, @optimizer_hints,
+          @wheres, @groups, @havings, @windows, @comment
         ].hash
       end
 
@@ -51,11 +53,13 @@ module Arel # :nodoc: all
         self.class == other.class &&
           self.source == other.source &&
           self.set_quantifier == other.set_quantifier &&
+          self.optimizer_hints == other.optimizer_hints &&
           self.projections == other.projections &&
           self.wheres == other.wheres &&
           self.groups == other.groups &&
           self.havings == other.havings &&
-          self.windows == other.windows
+          self.windows == other.windows &&
+          self.comment == other.comment
       end
       alias :== :eql?
     end

data/lib/arel/nodes/unary.rb

@@ -35,6 +35,7 @@ module Arel # :nodoc: all
       Not
       Offset
       On
+      OptimizerHints
       Ordering
       RollUp
     }.each do |name|

data/lib/arel/nodes/values_list.rb

@@ -2,23 +2,8 @@
 
 module Arel # :nodoc: all
   module Nodes
-    class ValuesList < Node
-      attr_reader :rows
-
-      def initialize(rows)
-        @rows = rows
-        super()
-      end
-
-      def hash
-        @rows.hash
-      end
-
-      def eql?(other)
-        self.class == other.class &&
-          self.rows == other.rows
-      end
-      alias :== :eql?
+    class ValuesList < Unary
+      alias :rows :expr
     end
   end
 end

data/lib/arel/select_manager.rb

@@ -146,6 +146,13 @@ module Arel # :nodoc: all
       @ctx.projections = projections
     end
 
+    def optimizer_hints(*hints)
+      unless hints.empty?
+        @ctx.optimizer_hints = Arel::Nodes::OptimizerHints.new(hints)
+      end
+      self
+    end
+
     def distinct(value = true)
       if value
         @ctx.set_quantifier = Arel::Nodes::Distinct.new
@@ -237,16 +244,9 @@ module Arel # :nodoc: all
       @ctx.source
     end
 
-    class Row < Struct.new(:data) # :nodoc:
-      def id
-        data["id"]
-      end
-
-      def method_missing(name, *args)
-        name = name.to_s
-        return data[name] if data.key?(name)
-        super
-      end
+    def comment(*values)
+      @ctx.comment = Nodes::Comment.new(values)
+      self
     end
 
     private

data/lib/arel/visitors/depth_first.rb

@@ -10,7 +10,7 @@ module Arel # :nodoc: all
 
       private
 
-        def visit(o)
+        def visit(o, _ = nil)
           super
           @block.call o
         end
@@ -35,6 +35,8 @@ module Arel # :nodoc: all
         alias :visit_Arel_Nodes_Ascending         :unary
         alias :visit_Arel_Nodes_Descending        :unary
         alias :visit_Arel_Nodes_UnqualifiedColumn :unary
+        alias :visit_Arel_Nodes_OptimizerHints    :unary
+        alias :visit_Arel_Nodes_ValuesList        :unary
 
         def function(o)
           visit o.expressions
@@ -102,7 +104,6 @@ module Arel # :nodoc: all
         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_When               :binary
 
         def visit_Arel_Nodes_StringJoin(o)
@@ -180,6 +181,10 @@ module Arel # :nodoc: all
           visit o.limit
         end
 
+        def visit_Arel_Nodes_Comment(o)
+          visit o.values
+        end
+
         def visit_Array(o)
           o.each { |i| visit i }
         end

data/lib/arel/visitors/dot.rb

@@ -46,8 +46,8 @@ module Arel # :nodoc: all
           visit_edge o, "distinct"
         end
 
-        def visit_Arel_Nodes_Values(o)
-          visit_edge o, "expressions"
+        def visit_Arel_Nodes_ValuesList(o)
+          visit_edge o, "rows"
         end
 
         def visit_Arel_Nodes_StringJoin(o)
@@ -82,6 +82,7 @@ module Arel # :nodoc: all
         alias :visit_Arel_Nodes_Offset            :unary
         alias :visit_Arel_Nodes_On                :unary
         alias :visit_Arel_Nodes_UnqualifiedColumn :unary
+        alias :visit_Arel_Nodes_OptimizerHints    :unary
         alias :visit_Arel_Nodes_Preceding         :unary
         alias :visit_Arel_Nodes_Following         :unary
         alias :visit_Arel_Nodes_Rows              :unary
@@ -233,6 +234,10 @@ module Arel # :nodoc: all
         end
         alias :visit_Set :visit_Array
 
+        def visit_Arel_Nodes_Comment(o)
+          visit_edge(o, "values")
+        end
+
         def visit_edge(o, method)
           edge(method) { visit o.send(method) }
         end

data/lib/arel/visitors/ibm_db.rb

@@ -4,6 +4,15 @@ module Arel # :nodoc: all
   module Visitors
     class IBM_DB < Arel::Visitors::ToSql
       private
+        def visit_Arel_Nodes_SelectCore(o, collector)
+          collector = super
+          maybe_visit o.optimizer_hints, collector
+        end
+
+        def visit_Arel_Nodes_OptimizerHints(o, collector)
+          hints = o.expr.map { |v| sanitize_as_sql_comment(v) }.join
+          collector << "/* <OPTGUIDELINES>#{hints}</OPTGUIDELINES> */"
+        end
 
         def visit_Arel_Nodes_Limit(o, collector)
           collector << "FETCH FIRST "
@@ -16,6 +25,10 @@ module Arel # :nodoc: all
           collector = visit [o.left, o.right, 0, 1], collector
           collector << ")"
         end
+
+        def collect_optimizer_hints(o, collector)
+          collector
+        end
     end
   end
 end

data/lib/arel/visitors/informix.rb

@@ -42,10 +42,16 @@ module Arel # :nodoc: all
           collector
         end
 
+        def visit_Arel_Nodes_OptimizerHints(o, collector)
+          hints = o.expr.map { |v| sanitize_as_sql_comment(v) }.join(", ")
+          collector << "/*+ #{hints} */"
+        end
+
         def visit_Arel_Nodes_Offset(o, collector)
           collector << "SKIP "
           visit o.expr, collector
         end
+
         def visit_Arel_Nodes_Limit(o, collector)
           collector << "FIRST "
           visit o.expr, collector

data/lib/arel/visitors/mssql.rb

@@ -76,6 +76,16 @@ module Arel # :nodoc: all
           end
         end
 
+        def visit_Arel_Nodes_SelectCore(o, collector)
+          collector = super
+          maybe_visit o.optimizer_hints, collector
+        end
+
+        def visit_Arel_Nodes_OptimizerHints(o, collector)
+          hints = o.expr.map { |v| sanitize_as_sql_comment(v) }.join(", ")
+          collector << "OPTION (#{hints})"
+        end
+
         def get_offset_limit_clause(o)
           first_row = o.offset ? o.offset.expr.to_i + 1 : 1
           last_row  = o.limit ? o.limit.expr.to_i - 1 + first_row : nil
@@ -97,12 +107,16 @@ module Arel # :nodoc: all
           collector = visit o.relation, collector
           if o.wheres.any?
             collector << " WHERE "
-            inject_join o.wheres, collector, AND
+            inject_join o.wheres, collector, " AND "
           else
             collector
           end
         end
 
+        def collect_optimizer_hints(o, collector)
+          collector
+        end
+
         def determine_order_by(orders, x)
           if orders.any?
             orders

data/lib/arel/visitors/oracle12.rb

@@ -8,11 +8,10 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_SelectStatement(o, collector)
           # Oracle does not allow LIMIT clause with select for update
           if o.limit && o.lock
-            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
+            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

data/lib/arel/visitors/postgresql.rb

@@ -3,11 +3,6 @@
 module Arel # :nodoc: all
   module Visitors
     class PostgreSQL < Arel::Visitors::ToSql
-      CUBE = "CUBE"
-      ROLLUP = "ROLLUP"
-      GROUPING_SETS = "GROUPING SETS"
-      LATERAL = "LATERAL"
-
       private
 
         def visit_Arel_Nodes_Matches(o, collector)
@@ -57,23 +52,22 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_Cube(o, collector)
-          collector << CUBE
+          collector << "CUBE"
           grouping_array_or_grouping_element o, collector
         end
 
         def visit_Arel_Nodes_RollUp(o, collector)
-          collector << ROLLUP
+          collector << "ROLLUP"
           grouping_array_or_grouping_element o, collector
         end
 
         def visit_Arel_Nodes_GroupingSet(o, collector)
-          collector << GROUPING_SETS
+          collector << "GROUPING SETS"
           grouping_array_or_grouping_element o, collector
         end
 
         def visit_Arel_Nodes_Lateral(o, collector)
-          collector << LATERAL
-          collector << SPACE
+          collector << "LATERAL "
           grouping_parentheses o, collector
         end
 

data/lib/arel/visitors/to_sql.rb

@@ -9,59 +9,6 @@ module Arel # :nodoc: all
     end
 
     class ToSql < Arel::Visitors::Visitor
-      ##
-      # This is some roflscale crazy stuff.  I'm roflscaling this because
-      # building SQL queries is a hotspot.  I will explain the roflscale so that
-      # others will not rm this code.
-      #
-      # In YARV, string literals in a method body will get duped when the byte
-      # code is executed.  Let's take a look:
-      #
-      # > puts RubyVM::InstructionSequence.new('def foo; "bar"; end').disasm
-      #
-      #   == disasm: <RubyVM::InstructionSequence:foo@<compiled>>=====
-      #    0000 trace            8
-      #    0002 trace            1
-      #    0004 putstring        "bar"
-      #    0006 trace            16
-      #    0008 leave
-      #
-      # The `putstring` bytecode will dup the string and push it on the stack.
-      # In many cases in our SQL visitor, that string is never mutated, so there
-      # is no need to dup the literal.
-      #
-      # If we change to a constant lookup, the string will not be duped, and we
-      # can reduce the objects in our system:
-      #
-      # > puts RubyVM::InstructionSequence.new('BAR = "bar"; def foo; BAR; end').disasm
-      #
-      #  == disasm: <RubyVM::InstructionSequence:foo@<compiled>>========
-      #  0000 trace            8
-      #  0002 trace            1
-      #  0004 getinlinecache   11, <ic:0>
-      #  0007 getconstant      :BAR
-      #  0009 setinlinecache   <ic:0>
-      #  0011 trace            16
-      #  0013 leave
-      #
-      # `getconstant` should be a hash lookup, and no object is duped when the
-      # value of the constant is pushed on the stack.  Hence the crazy
-      # constants below.
-      #
-      # `matches` and `doesNotMatch` operate case-insensitively via Visitor subclasses
-      # specialized for specific databases when necessary.
-      #
-
-      WHERE    = " WHERE "    # :nodoc:
-      SPACE    = " "          # :nodoc:
-      COMMA    = ", "         # :nodoc:
-      GROUP_BY = " GROUP BY " # :nodoc:
-      ORDER_BY = " ORDER BY " # :nodoc:
-      WINDOW   = " WINDOW "   # :nodoc:
-      AND      = " AND "      # :nodoc:
-
-      DISTINCT = "DISTINCT"   # :nodoc:
-
       def initialize(connection)
         super()
         @connection = connection
@@ -105,10 +52,14 @@ module Arel # :nodoc: all
         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 ', '})"
+
+          unless o.columns.empty?
+            collector << " ("
+            o.columns.each_with_index do |x, i|
+              collector << ", " unless i == 0
+              collector << quote_column_name(x.name)
+            end
+            collector << ")"
           end
 
           if o.values
@@ -150,48 +101,27 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_ValuesList(o, collector)
           collector << "VALUES "
 
-          len = o.rows.length - 1
-          o.rows.each_with_index { |row, i|
+          o.rows.each_with_index do |row, i|
+            collector << ", " unless i == 0
             collector << "("
-            row_len = row.length - 1
             row.each_with_index do |value, k|
+              collector << ", " unless k == 0
               case value
               when Nodes::SqlLiteral, Nodes::BindParam
                 collector = visit(value, collector)
               else
-                collector << quote(value)
+                collector << quote(value).to_s
               end
-              collector << COMMA unless k == row_len
             end
             collector << ")"
-            collector << COMMA unless i == len
-          }
+          end
           collector
         end
 
-        def visit_Arel_Nodes_Values(o, collector)
-          collector << "VALUES ("
-
-          len = o.expressions.length - 1
-          o.expressions.each_with_index { |value, i|
-            case value
-            when Nodes::SqlLiteral, Nodes::BindParam
-              collector = visit value, collector
-            else
-              collector << quote(value).to_s
-            end
-            unless i == len
-              collector << COMMA
-            end
-          }
-
-          collector << ")"
-        end
-
         def visit_Arel_Nodes_SelectStatement(o, collector)
           if o.with
             collector = visit o.with, collector
-            collector << SPACE
+            collector << " "
           end
 
           collector = o.cores.inject(collector) { |c, x|
@@ -199,12 +129,11 @@ module Arel # :nodoc: all
           }
 
           unless o.orders.empty?
-            collector << ORDER_BY
-            len = o.orders.length - 1
-            o.orders.each_with_index { |x, i|
+            collector << " ORDER BY "
+            o.orders.each_with_index do |x, i|
+              collector << ", " unless i == 0
               collector = visit(x, collector)
-              collector << COMMA unless len == i
-            }
+            end
           end
 
           visit_Arel_Nodes_SelectOptions(o, collector)
@@ -219,24 +148,34 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_SelectCore(o, collector)
           collector << "SELECT"
 
+          collector = collect_optimizer_hints(o, collector)
           collector = maybe_visit o.set_quantifier, collector
 
-          collect_nodes_for o.projections, collector, SPACE
+          collect_nodes_for o.projections, collector, " "
 
           if o.source && !o.source.empty?
             collector << " FROM "
             collector = visit o.source, collector
           end
 
-          collect_nodes_for o.wheres, collector, WHERE, AND
-          collect_nodes_for o.groups, collector, GROUP_BY
-          collect_nodes_for o.havings, collector, " HAVING ", AND
-          collect_nodes_for o.windows, collector, WINDOW
+          collect_nodes_for o.wheres, collector, " WHERE ", " AND "
+          collect_nodes_for o.groups, collector, " GROUP BY "
+          collect_nodes_for o.havings, collector, " HAVING ", " AND "
+          collect_nodes_for o.windows, collector, " WINDOW "
 
-          collector
+          maybe_visit o.comment, collector
+        end
+
+        def visit_Arel_Nodes_OptimizerHints(o, collector)
+          hints = o.expr.map { |v| sanitize_as_sql_comment(v) }.join(" ")
+          collector << "/*+ #{hints} */"
+        end
+
+        def visit_Arel_Nodes_Comment(o, collector)
+          collector << o.values.map { |v| "/* #{sanitize_as_sql_comment(v)} */" }.join(" ")
         end
 
-        def collect_nodes_for(nodes, collector, spacer, connector = COMMA)
+        def collect_nodes_for(nodes, collector, spacer, connector = ", ")
           unless nodes.empty?
             collector << spacer
             inject_join nodes, collector, connector
@@ -248,7 +187,7 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_Distinct(o, collector)
-          collector << DISTINCT
+          collector << "DISTINCT"
         end
 
         def visit_Arel_Nodes_DistinctOn(o, collector)
@@ -257,12 +196,12 @@ module Arel # :nodoc: all
 
         def visit_Arel_Nodes_With(o, collector)
           collector << "WITH "
-          inject_join o.children, collector, COMMA
+          inject_join o.children, collector, ", "
         end
 
         def visit_Arel_Nodes_WithRecursive(o, collector)
           collector << "WITH RECURSIVE "
-          inject_join o.children, collector, COMMA
+          inject_join o.children, collector, ", "
         end
 
         def visit_Arel_Nodes_Union(o, collector)
@@ -295,13 +234,13 @@ module Arel # :nodoc: all
           collect_nodes_for o.partitions, collector, "PARTITION BY "
 
           if o.orders.any?
-            collector << SPACE if o.partitions.any?
+            collector << " " if o.partitions.any?
             collector << "ORDER BY "
             collector = inject_join o.orders, collector, ", "
           end
 
           if o.framing
-            collector << SPACE if o.partitions.any? || o.orders.any?
+            collector << " " if o.partitions.any? || o.orders.any?
             collector = visit o.framing, collector
           end
 
@@ -506,8 +445,8 @@ module Arel # :nodoc: all
             collector = visit o.left, collector
           end
           if o.right.any?
-            collector << SPACE if o.left
-            collector = inject_join o.right, collector, SPACE
+            collector << " " if o.left
+            collector = inject_join o.right, collector, " "
           end
           collector
         end
@@ -527,7 +466,7 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_FullOuterJoin(o, collector)
           collector << "FULL OUTER JOIN "
           collector = visit o.left, collector
-          collector << SPACE
+          collector << " "
           visit o.right, collector
         end
 
@@ -541,7 +480,7 @@ module Arel # :nodoc: all
         def visit_Arel_Nodes_RightOuterJoin(o, collector)
           collector << "RIGHT OUTER JOIN "
           collector = visit o.left, collector
-          collector << SPACE
+          collector << " "
           visit o.right, collector
         end
 
@@ -549,7 +488,7 @@ module Arel # :nodoc: all
           collector << "INNER JOIN "
           collector = visit o.left, collector
           if o.right
-            collector << SPACE
+            collector << " "
             visit(o.right, collector)
           else
             collector
@@ -568,41 +507,73 @@ module Arel # :nodoc: all
 
         def visit_Arel_Table(o, collector)
           if o.table_alias
-            collector << "#{quote_table_name o.name} #{quote_table_name o.table_alias}"
+            collector << quote_table_name(o.name) << " " << quote_table_name(o.table_alias)
           else
             collector << quote_table_name(o.name)
           end
         end
 
         def visit_Arel_Nodes_In(o, collector)
-          if Array === o.right && !o.right.empty?
+          unless Array === o.right
+            return collect_in_clause(o.left, o.right, collector)
+          end
+
+          unless o.right.empty?
             o.right.delete_if { |value| unboundable?(value) }
           end
 
-          if Array === o.right && o.right.empty?
-            collector << "1=0"
+          return collector << "1=0" if o.right.empty?
+
+          in_clause_length = @connection.in_clause_length
+
+          if !in_clause_length || o.right.length <= in_clause_length
+            collect_in_clause(o.left, o.right, collector)
           else
-            collector = visit o.left, collector
-            collector << " IN ("
-            visit(o.right, collector) << ")"
+            collector << "("
+            o.right.each_slice(in_clause_length).each_with_index do |right, i|
+              collector << " OR " unless i == 0
+              collect_in_clause(o.left, right, collector)
+            end
+            collector << ")"
           end
         end
 
+        def collect_in_clause(left, right, collector)
+          collector = visit left, collector
+          collector << " IN ("
+          visit(right, collector) << ")"
+        end
+
         def visit_Arel_Nodes_NotIn(o, collector)
-          if Array === o.right && !o.right.empty?
+          unless Array === o.right
+            return collect_not_in_clause(o.left, o.right, collector)
+          end
+
+          unless o.right.empty?
             o.right.delete_if { |value| unboundable?(value) }
           end
 
-          if Array === o.right && o.right.empty?
-            collector << "1=1"
+          return collector << "1=1" if o.right.empty?
+
+          in_clause_length = @connection.in_clause_length
+
+          if !in_clause_length || o.right.length <= in_clause_length
+            collect_not_in_clause(o.left, o.right, collector)
           else
-            collector = visit o.left, collector
-            collector << " NOT IN ("
-            collector = visit o.right, collector
-            collector << ")"
+            o.right.each_slice(in_clause_length).each_with_index do |right, i|
+              collector << " AND " unless i == 0
+              collect_not_in_clause(o.left, right, collector)
+            end
+            collector
           end
         end
 
+        def collect_not_in_clause(left, right, collector)
+          collector = visit left, collector
+          collector << " NOT IN ("
+          visit(right, collector) << ")"
+        end
+
         def visit_Arel_Nodes_And(o, collector)
           inject_join o.children, collector, " AND "
         end
@@ -712,13 +683,12 @@ module Arel # :nodoc: all
         end
 
         def visit_Arel_Nodes_UnqualifiedColumn(o, collector)
-          collector << "#{quote_column_name o.name}"
-          collector
+          collector << quote_column_name(o.name)
         end
 
         def visit_Arel_Attributes_Attribute(o, collector)
           join_name = o.relation.table_alias || o.relation.name
-          collector << "#{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
@@ -799,6 +769,15 @@ module Arel # :nodoc: all
           @connection.quote_column_name(name)
         end
 
+        def sanitize_as_sql_comment(value)
+          return value if Arel::Nodes::SqlLiteral === value
+          @connection.sanitize_as_sql_comment(value)
+        end
+
+        def collect_optimizer_hints(o, collector)
+          maybe_visit o.optimizer_hints, collector
+        end
+
         def maybe_visit(thing, collector)
           return collector unless thing
           collector << " "
@@ -806,14 +785,11 @@ module Arel # :nodoc: all
         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
-          }
+          list.each_with_index do |x, i|
+            collector << join_str unless i == 0
+            collector = visit(x, collector)
+          end
+          collector
         end
 
         def unboundable?(value)