arel 4.0.0 → 4.0.1

data/lib/arel/visitors/dot.rb

@@ -28,41 +28,41 @@ module Arel
       end
 
       private
-      def visit_Arel_Nodes_Ordering o
-        visit_edge o, "expr"
+      def visit_Arel_Nodes_Ordering o, a
+        visit_edge o, a, "expr"
       end
 
-      def visit_Arel_Nodes_TableAlias o
-        visit_edge o, "name"
-        visit_edge o, "relation"
+      def visit_Arel_Nodes_TableAlias o, a
+        visit_edge o, a, "name"
+        visit_edge o, a, "relation"
       end
 
-      def visit_Arel_Nodes_Count o
-        visit_edge o, "expressions"
-        visit_edge o, "distinct"
+      def visit_Arel_Nodes_Count o, a
+        visit_edge o, a, "expressions"
+        visit_edge o, a, "distinct"
       end
 
-      def visit_Arel_Nodes_Values o
-        visit_edge o, "expressions"
+      def visit_Arel_Nodes_Values o, a
+        visit_edge o, a, "expressions"
       end
 
-      def visit_Arel_Nodes_StringJoin o
-        visit_edge o, "left"
+      def visit_Arel_Nodes_StringJoin o, a
+        visit_edge o, a, "left"
       end
 
-      def visit_Arel_Nodes_InnerJoin o
-        visit_edge o, "left"
-        visit_edge o, "right"
+      def visit_Arel_Nodes_InnerJoin o, a
+        visit_edge o, a, "left"
+        visit_edge o, a, "right"
       end
       alias :visit_Arel_Nodes_OuterJoin :visit_Arel_Nodes_InnerJoin
 
-      def visit_Arel_Nodes_DeleteStatement o
-        visit_edge o, "relation"
-        visit_edge o, "wheres"
+      def visit_Arel_Nodes_DeleteStatement o, a
+        visit_edge o, a, "relation"
+        visit_edge o, a, "wheres"
       end
 
-      def unary o
-        visit_edge o, "expr"
+      def unary o, a
+        visit_edge o, a, "expr"
       end
       alias :visit_Arel_Nodes_Group             :unary
       alias :visit_Arel_Nodes_Grouping          :unary
@@ -78,23 +78,23 @@ module Arel
       alias :visit_Arel_Nodes_Rows              :unary
       alias :visit_Arel_Nodes_Range             :unary
 
-      def window o
-        visit_edge o, "orders"
-        visit_edge o, "framing"
+      def window o, a
+        visit_edge o, a, "orders"
+        visit_edge o, a, "framing"
       end
       alias :visit_Arel_Nodes_Window            :window
 
-      def named_window o
-        visit_edge o, "orders"
-        visit_edge o, "framing"
-        visit_edge o, "name"        
+      def named_window o, a
+        visit_edge o, a, "orders"
+        visit_edge o, a, "framing"
+        visit_edge o, a, "name"
       end
       alias :visit_Arel_Nodes_NamedWindow       :named_window
 
-      def function o
-        visit_edge o, "expressions"
-        visit_edge o, "distinct"
-        visit_edge o, "alias"
+      def function o, a
+        visit_edge o, a, "expressions"
+        visit_edge o, a, "distinct"
+        visit_edge o, a, "alias"
       end
       alias :visit_Arel_Nodes_Exists :function
       alias :visit_Arel_Nodes_Min    :function
@@ -102,52 +102,52 @@ module Arel
       alias :visit_Arel_Nodes_Avg    :function
       alias :visit_Arel_Nodes_Sum    :function
 
-      def extract o
-        visit_edge o, "expressions"
-        visit_edge o, "alias"
+      def extract o, a
+        visit_edge o, a, "expressions"
+        visit_edge o, a, "alias"
       end
       alias :visit_Arel_Nodes_Extract :extract
 
-      def visit_Arel_Nodes_NamedFunction o
-        visit_edge o, "name"
-        visit_edge o, "expressions"
-        visit_edge o, "distinct"
-        visit_edge o, "alias"
+      def visit_Arel_Nodes_NamedFunction o, a
+        visit_edge o, a, "name"
+        visit_edge o, a, "expressions"
+        visit_edge o, a, "distinct"
+        visit_edge o, a, "alias"
       end
 
-      def visit_Arel_Nodes_InsertStatement o
-        visit_edge o, "relation"
-        visit_edge o, "columns"
-        visit_edge o, "values"
+      def visit_Arel_Nodes_InsertStatement o, a
+        visit_edge o, a, "relation"
+        visit_edge o, a, "columns"
+        visit_edge o, a, "values"
       end
 
-      def visit_Arel_Nodes_SelectCore o
-        visit_edge o, "source"
-        visit_edge o, "projections"
-        visit_edge o, "wheres"
-        visit_edge o, "windows"
+      def visit_Arel_Nodes_SelectCore o, a
+        visit_edge o, a, "source"
+        visit_edge o, a, "projections"
+        visit_edge o, a, "wheres"
+        visit_edge o, a, "windows"
       end
 
-      def visit_Arel_Nodes_SelectStatement o
-        visit_edge o, "cores"
-        visit_edge o, "limit"
-        visit_edge o, "orders"
-        visit_edge o, "offset"
+      def visit_Arel_Nodes_SelectStatement o, a
+        visit_edge o, a, "cores"
+        visit_edge o, a, "limit"
+        visit_edge o, a, "orders"
+        visit_edge o, a, "offset"
       end
 
-      def visit_Arel_Nodes_UpdateStatement o
-        visit_edge o, "relation"
-        visit_edge o, "wheres"
-        visit_edge o, "values"
+      def visit_Arel_Nodes_UpdateStatement o, a
+        visit_edge o, a, "relation"
+        visit_edge o, a, "wheres"
+        visit_edge o, a, "values"
       end
 
-      def visit_Arel_Table o
-        visit_edge o, "name"
+      def visit_Arel_Table o, a
+        visit_edge o, a, "name"
       end
 
-      def visit_Arel_Attribute o
-        visit_edge o, "relation"
-        visit_edge o, "name"
+      def visit_Arel_Attribute o, a
+        visit_edge o, a, "relation"
+        visit_edge o, a, "name"
       end
       alias :visit_Arel_Attributes_Integer :visit_Arel_Attribute
       alias :visit_Arel_Attributes_Float :visit_Arel_Attribute
@@ -156,16 +156,16 @@ module Arel
       alias :visit_Arel_Attributes_Boolean :visit_Arel_Attribute
       alias :visit_Arel_Attributes_Attribute :visit_Arel_Attribute
 
-      def nary o
+      def nary o, a
         o.children.each_with_index do |x,i|
-          edge(i) { visit x }
+          edge(i) { visit x, a }
         end
       end
       alias :visit_Arel_Nodes_And :nary
 
-      def binary o
-        visit_edge o, "left"
-        visit_edge o, "right"
+      def binary o, a
+        visit_edge o, a, "left"
+        visit_edge o, a, "right"
       end
       alias :visit_Arel_Nodes_As                 :binary
       alias :visit_Arel_Nodes_Assignment         :binary
@@ -184,7 +184,7 @@ module Arel
       alias :visit_Arel_Nodes_Or                 :binary
       alias :visit_Arel_Nodes_Over               :binary
 
-      def visit_String o
+      def visit_String o, a
         @node_stack.last.fields << o
       end
       alias :visit_Time :visit_String
@@ -201,23 +201,23 @@ module Arel
       alias :visit_Symbol :visit_String
       alias :visit_Arel_Nodes_SqlLiteral :visit_String
 
-      def visit_Hash o
+      def visit_Hash o, a
         o.each_with_index do |pair, i|
-          edge("pair_#{i}")   { visit pair }
+          edge("pair_#{i}")   { visit pair, a }
         end
       end
 
-      def visit_Array o
+      def visit_Array o, a
         o.each_with_index do |x,i|
-          edge(i) { visit x }
+          edge(i) { visit x, a }
         end
       end
 
-      def visit_edge o, method
-        edge(method) { visit o.send(method) }
+      def visit_edge o, a, method
+        edge(method) { visit o.send(method), a }
       end
 
-      def visit o
+      def visit o, a = nil
         if node = @seen[o.object_id]
           @edge_stack.last.to = node
           return

data/lib/arel/visitors/ibm_db.rb

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

data/lib/arel/visitors/informix.rb

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

data/lib/arel/visitors/join_sql.rb

@@ -11,8 +11,8 @@ module Arel
     module JoinSql
       private
 
-      def visit_Arel_Nodes_SelectCore o
-        o.source.right.map { |j| visit j }.join ' '
+      def visit_Arel_Nodes_SelectCore o, a
+        o.source.right.map { |j| visit j, a }.join ' '
       end
     end
   end

data/lib/arel/visitors/mssql.rb

@@ -6,20 +6,20 @@ module Arel
       # `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
+      def visit_Arel_Nodes_Top o, a
         ""
       end
 
-      def visit_Arel_Nodes_SelectStatement o
+      def visit_Arel_Nodes_SelectStatement o, a
         if !o.limit && !o.offset
-          return super o
+          return super o, a
         end
 
-        select_order_by = "ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?
+        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)
+          core_order_by = select_order_by || determine_order_by(x, a)
           if select_count? x
             x.projections = [row_num_literal(core_order_by)]
             is_select_count = true
@@ -27,7 +27,7 @@ module Arel
             x.projections << row_num_literal(core_order_by)
           end
 
-          visit_Arel_Nodes_SelectCore x
+          visit_Arel_Nodes_SelectCore x, a
         }.join
 
         sql = "SELECT _t.* FROM (#{sql}) as _t WHERE #{get_offset_limit_clause(o)}"
@@ -46,11 +46,11 @@ module Arel
         end
       end
 
-      def determine_order_by x
+      def determine_order_by x, a
         unless x.groups.empty?
-          "ORDER BY #{x.groups.map { |g| visit g }.join ', ' }"
+          "ORDER BY #{x.groups.map { |g| visit g, a }.join ', ' }"
         else
-          "ORDER BY #{find_left_table_pk(x.froms)}"
+          "ORDER BY #{find_left_table_pk(x.froms, a)}"
         end
       end
 
@@ -64,9 +64,9 @@ module Arel
 
       # fixme raise exception of there is no pk?
       # fixme!! Table.primary_key will be depricated. What is the replacement??
-      def find_left_table_pk o
-        return visit o.primary_key if o.instance_of? Arel::Table
-        find_left_table_pk o.left if o.kind_of? Arel::Nodes::Join
+      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
       end
     end
   end

data/lib/arel/visitors/mysql.rb

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

data/lib/arel/visitors/oracle.rb

@@ -3,12 +3,12 @@ module Arel
     class Oracle < Arel::Visitors::ToSql
       private
 
-      def visit_Arel_Nodes_SelectStatement o
-        o = order_hacks(o)
+      def visit_Arel_Nodes_SelectStatement o, a
+        o = order_hacks(o, a)
 
         # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
         # then can use simple ROWNUM in WHERE clause
-        if o.limit && o.orders.empty? && !o.offset && o.cores.first.projections.first !~ /^DISTINCT /
+        if o.limit && o.orders.empty? && !o.offset && o.cores.first.set_quantifier.class.to_s !~ /Distinct/
           o.cores.last.wheres.push Nodes::LessThanOrEqual.new(
             Nodes::SqlLiteral.new('ROWNUM'), o.limit.expr
           )
@@ -20,53 +20,53 @@ module Arel
           limit    = o.limit.expr.to_i
           offset   = o.offset
           o.offset = nil
-          sql = super(o)
+          sql = super(o, a)
           return <<-eosql
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
                 FROM (#{sql}) raw_sql_
                 WHERE rownum <= #{offset.expr.to_i + limit}
               )
-              WHERE #{visit offset}
+              WHERE #{visit offset, a}
           eosql
         end
 
         if o.limit
           o       = o.dup
           limit   = o.limit.expr
-          return "SELECT * FROM (#{super(o)}) WHERE ROWNUM <= #{visit limit}"
+          return "SELECT * FROM (#{super(o, a)}) WHERE ROWNUM <= #{visit limit, a}"
         end
 
         if o.offset
           o        = o.dup
           offset   = o.offset
           o.offset = nil
-          sql = super(o)
+          sql = super(o, a)
           return <<-eosql
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
                 FROM (#{sql}) raw_sql_
               )
-              WHERE #{visit offset}
+              WHERE #{visit offset, a}
           eosql
         end
 
         super
       end
 
-      def visit_Arel_Nodes_Limit o
+      def visit_Arel_Nodes_Limit o, a
       end
 
-      def visit_Arel_Nodes_Offset o
-        "raw_rnum_ > #{visit o.expr}"
+      def visit_Arel_Nodes_Offset o, a
+        "raw_rnum_ > #{visit o.expr, a}"
       end
 
-      def visit_Arel_Nodes_Except o
-        "( #{visit o.left} MINUS #{visit o.right} )"
+      def visit_Arel_Nodes_Except o, a
+        "( #{visit o.left, a} MINUS #{visit o.right, a} )"
       end
 
-      def visit_Arel_Nodes_UpdateStatement o
-        # Oracle does not allow ORDER BY/LIMIT in UPDATEs. 
+      def visit_Arel_Nodes_UpdateStatement o, a
+        # 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,
           # otherwise let the user deal with the error
@@ -79,19 +79,19 @@ module Arel
 
       ###
       # Hacks for the order clauses specific to Oracle
-      def order_hacks o
+      def order_hacks o, a
         return o if o.orders.empty?
         return o unless o.cores.any? do |core|
           core.projections.any? do |projection|
-            /DISTINCT.*FIRST_VALUE/ === projection
+            /FIRST_VALUE/ === projection
           end
         end
         # 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 }.join(', ').split(',')
+        # orders   = o.orders.map { |x| visit x, a }.join(', ').split(',')
         orders   = o.orders.map do |x|
-          string = visit x
+          string = visit x, a
           if string.include?(',')
             split_order_string(string)
           else