arel 6.0.4 → 7.1.4

data/lib/arel/visitors/oracle12.rb

@@ -0,0 +1,59 @@
+module Arel
+  module Visitors
+    class Oracle12 < Arel::Visitors::ToSql
+      private
+
+      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
+        end
+        super
+      end
+
+      def visit_Arel_Nodes_SelectOptions o, collector
+        collector = maybe_visit o.offset, collector
+        collector = maybe_visit o.limit, collector
+        collector = maybe_visit o.lock, collector
+      end
+
+      def visit_Arel_Nodes_Limit o, collector
+        collector << "FETCH FIRST "
+        collector = visit o.expr, collector
+        collector << " ROWS ONLY"
+      end
+
+      def visit_Arel_Nodes_Offset o, collector
+        collector << "OFFSET "
+        visit o.expr, collector
+        collector << " ROWS"
+      end
+
+      def visit_Arel_Nodes_Except o, collector
+        collector << "( "
+        collector = infix_value o, collector, " MINUS "
+        collector << " )"
+      end
+
+      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,
+          # otherwise let the user deal with the error
+          o = o.dup
+          o.orders = []
+        end
+
+        super
+      end
+
+      def visit_Arel_Nodes_BindParam o, collector
+        collector.add_bind(o) { |i| ":a#{i}" }
+      end
+    end
+  end
+end

data/lib/arel/visitors/postgresql.rb

@@ -1,22 +1,42 @@
 module Arel
   module Visitors
     class PostgreSQL < Arel::Visitors::ToSql
+      CUBE = 'CUBE'
+      ROLLUP = 'ROLLUP'
+      GROUPING_SET = 'GROUPING SET'
+
       private
 
       def visit_Arel_Nodes_Matches o, collector
-        infix_value o, collector, ' ILIKE '
+        op = o.case_sensitive ? ' LIKE ' : ' ILIKE '
+        collector = infix_value o, collector, op
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
       end
 
       def visit_Arel_Nodes_DoesNotMatch o, collector
-        infix_value o, collector, ' NOT ILIKE '
+        op = o.case_sensitive ? ' NOT LIKE ' : ' NOT ILIKE '
+        collector = infix_value o, collector, op
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
       end
 
       def visit_Arel_Nodes_Regexp o, collector
-        infix_value o, collector, ' ~ '
+        op = o.case_sensitive ? ' ~ ' : ' ~* '
+        infix_value o, collector, op
       end
 
       def visit_Arel_Nodes_NotRegexp o, collector
-        infix_value o, collector, ' !~ '
+        op = o.case_sensitive ? ' !~ ' : ' !~* '
+        infix_value o, collector, op
       end
 
       def visit_Arel_Nodes_DistinctOn o, collector
@@ -27,6 +47,38 @@ module Arel
       def visit_Arel_Nodes_BindParam o, collector
         collector.add_bind(o) { |i| "$#{i}" }
       end
+
+      def visit_Arel_Nodes_GroupingElement o, collector
+        collector << "( "
+        visit(o.expr, collector) << " )"
+      end
+
+      def visit_Arel_Nodes_Cube o, collector
+        collector << CUBE
+        grouping_array_or_grouping_element o, collector
+      end
+
+      def visit_Arel_Nodes_RollUp o, collector
+        collector << ROLLUP
+        grouping_array_or_grouping_element o, collector
+      end
+
+      def visit_Arel_Nodes_GroupingSet o, collector
+        collector << GROUPING_SET
+        grouping_array_or_grouping_element o, collector
+      end
+
+      # Utilized by GroupingSet, Cube & RollUp visitors to
+      # handle grouping aggregation semantics
+      def grouping_array_or_grouping_element o, collector
+        if o.expr.is_a? Array
+          collector << "( "
+          visit o.expr, collector
+          collector << " )"
+        else
+          visit o.expr, collector
+        end
+      end
     end
   end
 end

data/lib/arel/visitors/sqlite.rb

@@ -12,6 +12,15 @@ module Arel
         o.limit = Arel::Nodes::Limit.new(-1) if o.offset && !o.limit
         super
       end
+
+      def visit_Arel_Nodes_True o, collector
+        collector << "1"
+      end
+
+      def visit_Arel_Nodes_False o, collector
+        collector << "0"
+      end
+
     end
   end
 end

data/lib/arel/visitors/to_sql.rb

@@ -4,6 +4,12 @@ require 'arel/visitors/reduce'
 
 module Arel
   module Visitors
+    class UnsupportedVisitError < StandardError
+      def initialize(object)
+        super "Unsupported argument type: #{object.class.name}. Construct an Arel node instead."
+      end
+    end
+
     class ToSql < Arel::Visitors::Reduce
       ##
       # This is some roflscale crazy stuff.  I'm roflscaling this because
@@ -74,14 +80,14 @@ module Arel
       end
 
       def visit_Arel_Nodes_DeleteStatement o, collector
-        collector << "DELETE FROM "
+        collector << 'DELETE FROM '
         collector = visit o.relation, collector
         if o.wheres.any?
-          collector << " WHERE "
-          inject_join o.wheres, collector, AND
-        else
-          collector
+          collector << ' WHERE '
+          collector = inject_join o.wheres, collector, AND
         end
+
+        maybe_visit o.limit, collector
       end
 
       # FIXME: we should probably have a 2-pass visitor for this
@@ -164,7 +170,7 @@ module Arel
       end
 
       def table_exists? name
-        schema_cache.table_exists? name
+        schema_cache.data_source_exists?(name)
       end
 
       def column_for attr
@@ -193,7 +199,7 @@ module Arel
             collector << quote(value, attr && column_for(attr)).to_s
           end
           unless i == len
-            collector << ', '
+            collector << COMMA
           end
         }
 
@@ -211,7 +217,6 @@ module Arel
         }
 
         unless o.orders.empty?
-          collector << SPACE
           collector << ORDER_BY
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
@@ -220,11 +225,15 @@ module Arel
           }
         end
 
+        visit_Arel_Nodes_SelectOptions(o, collector)
+
+        collector
+      end
+
+      def visit_Arel_Nodes_SelectOptions o, collector
         collector = maybe_visit o.limit, collector
         collector = maybe_visit o.offset, collector
         collector = maybe_visit o.lock, collector
-
-        collector
       end
 
       def visit_Arel_Nodes_SelectCore o, collector
@@ -234,50 +243,33 @@ module Arel
 
         collector = maybe_visit o.set_quantifier, collector
 
-        unless o.projections.empty?
-          collector << SPACE
-          len = o.projections.length - 1
-          o.projections.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
+        collect_nodes_for o.projections, collector, SPACE
 
         if o.source && !o.source.empty?
           collector << " FROM "
           collector = visit o.source, collector
         end
 
-        unless o.wheres.empty?
-          collector << WHERE
-          len = o.wheres.length - 1
-          o.wheres.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << AND unless len == i
-          end
+        collect_nodes_for o.wheres, collector, WHERE, AND
+        collect_nodes_for o.groups, collector, GROUP_BY
+        unless o.havings.empty?
+          collector << " HAVING "
+          inject_join o.havings, collector, AND
         end
+        collect_nodes_for o.windows, collector, WINDOW
 
-        unless o.groups.empty?
-          collector << GROUP_BY
-          len = o.groups.length - 1
-          o.groups.each_with_index do |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          end
-        end
-
-        collector = maybe_visit o.having, collector
+        collector
+      end
 
-        unless o.windows.empty?
-          collector << WINDOW
-          len = o.windows.length - 1
-          o.windows.each_with_index do |x, i|
+      def collect_nodes_for nodes, collector, spacer, connector = COMMA
+        unless nodes.empty?
+          collector << spacer
+          len = nodes.length - 1
+          nodes.each_with_index do |x, i|
             collector = visit(x, collector)
-            collector << COMMA unless len == i
+            collector << connector unless len == i
           end
         end
-
-        collector
       end
 
       def visit_Arel_Nodes_Bin o, collector
@@ -337,13 +329,13 @@ module Arel
         end
 
         if o.orders.any?
-          collector << ' ' if o.partitions.any?
+          collector << SPACE 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 << SPACE if o.partitions.any? or o.orders.any?
           collector = visit o.framing, collector
         end
 
@@ -405,11 +397,6 @@ module Arel
         end
       end
 
-      def visit_Arel_Nodes_Having o, collector
-        collector << "HAVING "
-        visit o.expr, collector
-      end
-
       def visit_Arel_Nodes_Offset o, collector
         collector << "OFFSET "
         visit o.expr, collector
@@ -557,7 +544,7 @@ module Arel
           collector = visit o.left, collector
         end
         if o.right.any?
-          collector << " " if o.left
+          collector << SPACE if o.left
           collector = inject_join o.right, collector, ' '
         end
         collector
@@ -701,6 +688,35 @@ module Arel
         visit o.right, collector
       end
 
+      def visit_Arel_Nodes_Case o, collector
+        collector << "CASE "
+        if o.case
+          visit o.case, collector
+          collector << " "
+        end
+        o.conditions.each do |condition|
+          visit condition, collector
+          collector << " "
+        end
+        if o.default
+          visit o.default, collector
+          collector << " "
+        end
+        collector << "END"
+      end
+
+      def visit_Arel_Nodes_When o, collector
+        collector << "WHEN "
+        visit o.left, collector
+        collector << " THEN "
+        visit o.right, collector
+      end
+
+      def visit_Arel_Nodes_Else o, collector
+        collector << "ELSE "
+        visit o.expr, collector
+      end
+
       def visit_Arel_Nodes_UnqualifiedColumn o, collector
         collector << "#{quote_column_name o.name}"
         collector
@@ -729,11 +745,15 @@ module Arel
       alias :visit_Integer               :literal
 
       def quoted o, a
-        quote(o, column_for(a))
+        if a && a.able_to_type_cast?
+          quote(a.type_cast_for_database(o))
+        else
+          quote(o, column_for(a))
+        end
       end
 
       def unsupported o, collector
-        raise "unsupported: #{o.class.name}"
+        raise UnsupportedVisitError.new(o)
       end
 
       alias :visit_ActiveSupport_Multibyte_Chars :unsupported
@@ -762,6 +782,11 @@ module Arel
       alias :visit_Arel_Nodes_Multiplication :visit_Arel_Nodes_InfixOperation
       alias :visit_Arel_Nodes_Division       :visit_Arel_Nodes_InfixOperation
 
+      def visit_Arel_Nodes_UnaryOperation o, collector
+        collector << " #{o.operator} "
+        visit o.expr, collector
+      end
+
       def visit_Array o, collector
         inject_join o, collector, ", "
       end
@@ -769,6 +794,9 @@ module Arel
 
       def quote value, column = nil
         return value if Arel::Nodes::SqlLiteral === value
+        if column
+          print_type_cast_deprecation
+        end
         @connection.quote value, column
       end
 
@@ -818,6 +846,20 @@ module Arel
           collector
         end
       end
+
+      def print_type_cast_deprecation
+        unless defined?($arel_silence_type_casting_deprecation) && $arel_silence_type_casting_deprecation
+          warn <<-eowarn
+Arel performing automatic type casting is deprecated, and will be removed in Arel 8.0. If you are seeing this, it is because you are manually passing a value to an Arel predicate, and the `Arel::Table` object was constructed manually. The easiest way to remove this warning is to use an `Arel::Table` object returned from calling `arel_table` on an ActiveRecord::Base subclass.
+
+If you're certain the value is already of the right type, change `attribute.eq(value)` to `attribute.eq(Arel::Nodes::Quoted.new(value))` (you will be able to remove that in Arel 8.0, it is only required to silence this deprecation warning).
+
+You can also silence this warning globally by setting `$arel_silence_type_casting_deprecation` to `true`. (Do NOT do this if you are a library author)
+
+If you are passing user input to a predicate, you must either give an appropriate type caster object to the `Arel::Table`, or manually cast the value before passing it to Arel.
+          eowarn
+        end
+      end
     end
   end
 end

data/lib/arel/visitors/where_sql.rb

@@ -1,11 +1,20 @@
 module Arel
   module Visitors
     class WhereSql < Arel::Visitors::ToSql
+      def initialize(inner_visitor, *args, &block)
+        @inner_visitor = inner_visitor
+        super(*args, &block)
+      end
+
       private
 
       def visit_Arel_Nodes_SelectCore o, collector
         collector << "WHERE "
-        inject_join o.wheres, collector, ' AND '
+        wheres = o.wheres.map do |where|
+          Nodes::SqlLiteral.new(@inner_visitor.accept(where, collector.class.new).value)
+        end
+
+        inject_join wheres, collector, ' AND '
       end
     end
   end