arel 5.0.1.20140414130214 → 6.0.0.beta1

data/lib/arel/visitors/ibm_db.rb

@@ -3,8 +3,10 @@ module Arel
     class IBM_DB < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_Limit o, a
-        "FETCH FIRST #{visit o.expr, a} ROWS ONLY"
+      def visit_Arel_Nodes_Limit o, collector
+        collector << "FETCH FIRST "
+        collector = visit o.expr, collector
+        collector << " ROWS ONLY"
       end
 
     end

data/lib/arel/visitors/informix.rb

@@ -2,30 +2,48 @@ module Arel
   module Visitors
     class Informix < Arel::Visitors::ToSql
       private
-      def visit_Arel_Nodes_SelectStatement o, a
-        [
-          "SELECT",
-          (visit(o.offset, a) if o.offset),
-          (visit(o.limit, a) if o.limit),
-          o.cores.map { |x| visit_Arel_Nodes_SelectCore x, a }.join,
-          ("ORDER BY #{o.orders.map { |x| visit x, a }.join(', ')}" unless o.orders.empty?),
-          (visit(o.lock, a) if o.lock),
-        ].compact.join ' '
+      def visit_Arel_Nodes_SelectStatement o, collector
+        collector << "SELECT "
+        collector = maybe_visit o.offset, collector
+        collector = maybe_visit o.limit, collector
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore x, c
+        }
+        if o.orders.any?
+          collector << "ORDER BY "
+          collector = inject_join o.orders, collector, ", "
+        end
+        collector = maybe_visit o.lock, collector
       end
-      def visit_Arel_Nodes_SelectCore o, a
-        [
-          "#{o.projections.map { |x| visit x, a }.join ', '}",
-          ("FROM #{visit(o.source, a)}" if o.source && !o.source.empty?),
-          ("WHERE #{o.wheres.map { |x| visit x, a }.join ' AND ' }" unless o.wheres.empty?),
-          ("GROUP BY #{o.groups.map { |x| visit x, a }.join ', ' }" unless o.groups.empty?),
-          (visit(o.having, a) if o.having),
-        ].compact.join ' '
+      def visit_Arel_Nodes_SelectCore o, collector
+        collector = inject_join o.projections, collector, ", "
+        froms = false
+        if o.source && !o.source.empty?
+          froms = true
+          collector << " FROM "
+          collector = visit o.source, collector
+        end
+
+        if o.wheres.any?
+          collector << " WHERE "
+          collector = inject_join o.wheres, collector, " AND "
+        end
+
+        if o.groups.any?
+          collector << "GROUP BY "
+          collector = inject_join o.groups, collector, ", "
+        end
+
+        maybe_visit o.having, collector
       end
-      def visit_Arel_Nodes_Offset o, a
-        "SKIP #{visit o.expr, a}"
+      def visit_Arel_Nodes_Offset o, collector
+        collector << "SKIP "
+        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
+        collector << " "
       end
     end
   end

data/lib/arel/visitors/mssql.rb

@@ -1,39 +1,54 @@
 module Arel
   module Visitors
     class MSSQL < Arel::Visitors::ToSql
+      RowNumber = Struct.new :children
+
       private
 
       # `top` wouldn't really work here. I.e. User.select("distinct first_name").limit(10) would generate
       # "select top 10 distinct first_name from users", which is invalid query! it should be
       # "select distinct top 10 first_name from users"
-      def visit_Arel_Nodes_Top o, a
+      def visit_Arel_Nodes_Top o
         ""
       end
 
-      def visit_Arel_Nodes_SelectStatement o, a
+      def visit_Arel_Visitors_MSSQL_RowNumber o, collector
+        collector << "ROW_NUMBER() OVER (ORDER BY "
+        inject_join(o.children, collector, ', ') << ") as _row_num"
+      end
+
+      def visit_Arel_Nodes_SelectStatement o, collector
         if !o.limit && !o.offset
-          return super o, a
+          return super
         end
 
-        select_order_by = "ORDER BY #{o.orders.map { |x| visit x, a }.join(', ')}" unless o.orders.empty?
-
         is_select_count = false
-        sql = o.cores.map { |x|
-          core_order_by = select_order_by || determine_order_by(x, a)
+        o.cores.each { |x|
+          core_order_by = row_num_literal determine_order_by(o.orders, x)
           if select_count? x
-            x.projections = [row_num_literal(core_order_by)]
+            x.projections = [core_order_by]
             is_select_count = true
           else
-            x.projections << row_num_literal(core_order_by)
+            x.projections << core_order_by
           end
+        }
 
-          visit_Arel_Nodes_SelectCore x, a
-        }.join
+        if is_select_count
+          # fixme count distinct wouldn't work with limit or offset
+          collector << "SELECT COUNT(1) as count_id FROM ("
+        end
+
+        collector << "SELECT _t.* FROM ("
+        collector = o.cores.inject(collector) { |c,x|
+          visit_Arel_Nodes_SelectCore x, c
+        }
+        collector << ") as _t WHERE #{get_offset_limit_clause(o)}"
 
-        sql = "SELECT _t.* FROM (#{sql}) as _t WHERE #{get_offset_limit_clause(o)}"
-        # fixme count distinct wouldn't work with limit or offset
-        sql = "SELECT COUNT(1) as count_id FROM (#{sql}) AS subquery" if is_select_count
-        sql
+        if is_select_count
+          collector << ") AS subquery"
+        else
+          collector
+        end
       end
 
       def get_offset_limit_clause o
@@ -46,16 +61,19 @@ module Arel
         end
       end
 
-      def determine_order_by x, a
-        unless x.groups.empty?
-          "ORDER BY #{x.groups.map { |g| visit g, a }.join ', ' }"
+      def determine_order_by orders, x
+        if orders.any?
+          orders
+        elsif x.groups.any?
+          x.groups
         else
-          "ORDER BY #{find_left_table_pk(x.froms, a)}"
+          pk = find_left_table_pk(x.froms)
+          pk ? [pk] : []
         end
       end
 
       def row_num_literal order_by
-        Nodes::SqlLiteral.new("ROW_NUMBER() OVER (#{order_by}) as _row_num")
+        RowNumber.new order_by
       end
 
       def select_count? x
@@ -64,9 +82,9 @@ module Arel
 
       # FIXME raise exception of there is no pk?
       # FIXME!! Table.primary_key will be deprecated. What is the replacement??
-      def find_left_table_pk o, a
-        return visit o.primary_key, a if o.instance_of? Arel::Table
-        find_left_table_pk o.left, a if o.kind_of? Arel::Nodes::Join
+      def find_left_table_pk o
+        return o.primary_key if o.instance_of? Arel::Table
+        find_left_table_pk o.left if o.kind_of? Arel::Nodes::Join
       end
     end
   end

data/lib/arel/visitors/mysql.rb

@@ -2,53 +2,79 @@ module Arel
   module Visitors
     class MySQL < Arel::Visitors::ToSql
       private
-      def visit_Arel_Nodes_Union o, a, suppress_parens = false
-        left_result = case o.left
+      def visit_Arel_Nodes_Union o, collector, suppress_parens = false
+        unless suppress_parens
+          collector << "( "
+        end
+
+        collector =   case o.left
                       when Arel::Nodes::Union
-                        visit_Arel_Nodes_Union o.left, a, true
+                        visit_Arel_Nodes_Union o.left, collector, true
                       else
-                        visit o.left, a
+                        visit o.left, collector
                       end
 
-        right_result = case o.right
+        collector << " UNION "
+
+        collector =    case o.right
                        when Arel::Nodes::Union
-                         visit_Arel_Nodes_Union o.right, a, true
+                         visit_Arel_Nodes_Union o.right, collector, true
                        else
-                         visit o.right, a
+                         visit o.right, collector
                        end
 
         if suppress_parens
-          "#{left_result} UNION #{right_result}"
+          collector
         else
-          "( #{left_result} UNION #{right_result} )"
+          collector << " )"
         end
       end
 
-      def visit_Arel_Nodes_Bin o, a
-        "BINARY #{visit o.expr, a}"
+      def visit_Arel_Nodes_Bin o, collector
+        collector << "BINARY "
+        visit o.expr, collector
       end
 
       ###
       # :'(
       # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
-      def visit_Arel_Nodes_SelectStatement o, a
-        o.limit = Arel::Nodes::Limit.new(18446744073709551615) if o.offset && !o.limit
+      def visit_Arel_Nodes_SelectStatement o, collector
+        if o.offset && !o.limit
+          o.limit = Arel::Nodes::Limit.new(Nodes.build_quoted(18446744073709551615))
+        end
         super
       end
 
-      def visit_Arel_Nodes_SelectCore o, a
+      def visit_Arel_Nodes_SelectCore o, collector
         o.froms ||= Arel.sql('DUAL')
         super
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
-        [
-          "UPDATE #{visit o.relation, a}",
-          ("SET #{o.values.map { |value| visit value, a }.join ', '}" unless o.values.empty?),
-          ("WHERE #{o.wheres.map { |x| visit x, a }.join ' AND '}" unless o.wheres.empty?),
-          ("ORDER BY #{o.orders.map { |x| visit x, a }.join(', ')}" unless o.orders.empty?),
-          (visit(o.limit, a) if o.limit),
-        ].compact.join ' '
+      def visit_Arel_Nodes_UpdateStatement o, collector
+        collector << "UPDATE "
+        collector = visit o.relation, collector
+
+        unless o.values.empty?
+          collector << " SET "
+          collector = inject_join o.values, collector, ', '
+        end
+
+        unless o.wheres.empty?
+          collector << " WHERE "
+          collector = inject_join o.wheres, collector, ' AND '
+        end
+
+        unless o.orders.empty?
+          collector << " ORDER BY "
+          collector = inject_join o.orders, collector, ', '
+        end
+
+        if o.limit
+          collector << " "
+          visit(o.limit, collector)
+        else
+          collector
+        end
       end
 
     end

data/lib/arel/visitors/oracle.rb

@@ -3,8 +3,8 @@ module Arel
     class Oracle < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_SelectStatement o, a
-        o = order_hacks(o, a)
+      def visit_Arel_Nodes_SelectStatement o, collector
+        o = order_hacks(o)
 
         # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
         # then can use simple ROWNUM in WHERE clause
@@ -17,55 +17,64 @@ module Arel
 
         if o.limit && o.offset
           o        = o.dup
-          limit    = o.limit.expr.to_i
+          limit    = o.limit.expr.expr
           offset   = o.offset
           o.offset = nil
-          sql = super(o, a)
-          return <<-eosql
+          collector << "
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
-                FROM (#{sql}) raw_sql_
+                FROM ("
+
+          collector = super(o, collector)
+          collector << ") raw_sql_
                 WHERE rownum <= #{offset.expr.to_i + limit}
               )
-              WHERE #{visit offset, a}
-          eosql
+              WHERE "
+          return visit(offset, collector)
         end
 
         if o.limit
           o       = o.dup
           limit   = o.limit.expr
-          return "SELECT * FROM (#{super(o, a)}) WHERE ROWNUM <= #{visit limit, a}"
+          collector << "SELECT * FROM ("
+          collector = super(o, collector)
+          collector << ") WHERE ROWNUM <= "
+          return visit limit, collector
         end
 
         if o.offset
           o        = o.dup
           offset   = o.offset
           o.offset = nil
-          sql = super(o, a)
-          return <<-eosql
-              SELECT * FROM (
+          collector << "SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
-                FROM (#{sql}) raw_sql_
+                FROM ("
+          collector = super(o, collector)
+          collector << ") raw_sql_
               )
-              WHERE #{visit offset, a}
-          eosql
+              WHERE "
+          return visit offset, collector
         end
 
         super
       end
 
-      def visit_Arel_Nodes_Limit o, a
+      def visit_Arel_Nodes_Limit o, collector
+        collector
       end
 
-      def visit_Arel_Nodes_Offset o, a
-        "raw_rnum_ > #{visit o.expr, a}"
+      def visit_Arel_Nodes_Offset o, collector
+        collector << "raw_rnum_ > "
+        visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Except o, a
-        "( #{visit o.left, a} MINUS #{visit o.right, a} )"
+      def visit_Arel_Nodes_Except o, collector
+        collector << "( "
+        collector = infix_value o, collector, " MINUS "
+        collector << " )"
       end
 
-      def visit_Arel_Nodes_UpdateStatement o, a
+      def visit_Arel_Nodes_UpdateStatement o, collector
         # Oracle does not allow ORDER BY/LIMIT in UPDATEs.
         if o.orders.any? && o.limit.nil?
           # However, there is no harm in silently eating the ORDER BY clause if no LIMIT has been provided,
@@ -79,7 +88,7 @@ module Arel
 
       ###
       # Hacks for the order clauses specific to Oracle
-      def order_hacks o, a
+      def order_hacks o
         return o if o.orders.empty?
         return o unless o.cores.any? do |core|
           core.projections.any? do |projection|
@@ -89,9 +98,9 @@ module Arel
         # Previous version with join and split broke ORDER BY clause
         # if it contained functions with several arguments (separated by ',').
         #
-        # orders   = o.orders.map { |x| visit x, a }.join(', ').split(',')
+        # orders   = o.orders.map { |x| visit x }.join(', ').split(',')
         orders   = o.orders.map do |x|
-          string = visit x, a
+          string = visit(x, Arel::Collectors::SQLString.new).value
           if string.include?(',')
             split_order_string(string)
           else

data/lib/arel/visitors/postgresql.rb

@@ -3,18 +3,25 @@ module Arel
     class PostgreSQL < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_Matches o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} ILIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_Matches o, collector
+        infix_value o, collector, ' ILIKE '
       end
 
-      def visit_Arel_Nodes_DoesNotMatch o, a
-        a = o.left if Arel::Attributes::Attribute === o.left
-        "#{visit o.left, a} NOT ILIKE #{visit o.right, a}"
+      def visit_Arel_Nodes_DoesNotMatch o, collector
+        infix_value o, collector, ' NOT ILIKE '
       end
 
-      def visit_Arel_Nodes_DistinctOn o, a
-        "DISTINCT ON ( #{visit o.expr, a} )"
+      def visit_Arel_Nodes_Regexp o, collector
+        infix_value o, collector, ' ~ '
+      end
+
+      def visit_Arel_Nodes_NotRegexp o, collector
+        infix_value o, collector, ' !~ '
+      end
+
+      def visit_Arel_Nodes_DistinctOn o, collector
+        collector << "DISTINCT ON ( "
+        visit(o.expr, collector) << " )"
       end
     end
   end

data/lib/arel/visitors/reduce.rb

@@ -0,0 +1,25 @@
+require 'arel/visitors/visitor'
+
+module Arel
+  module Visitors
+    class Reduce < Arel::Visitors::Visitor
+      def accept object, collector
+        visit object, collector
+      end
+
+      private
+
+      def visit object, collector
+        send dispatch[object.class], object, collector
+      rescue NoMethodError => e
+        raise e if respond_to?(dispatch[object.class], true)
+        superklass = object.class.ancestors.find { |klass|
+          respond_to?(dispatch[klass], true)
+        }
+        raise(TypeError, "Cannot visit #{object.class}") unless superklass
+        dispatch[object.class] = dispatch[superklass]
+        retry
+      end
+    end
+  end
+end