activerecord 5.2.8.1 → 6.0.0.beta1

data/lib/arel/visitors/oracle.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Oracle < Arel::Visitors::ToSql
+      private
+
+        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
+          if o.limit && o.orders.empty? && o.cores.first.groups.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
+            )
+            return super
+          end
+
+          if o.limit && o.offset
+            o        = o.dup
+            limit    = o.limit.expr
+            offset   = o.offset
+            o.offset = nil
+            collector << "
+                SELECT * FROM (
+                  SELECT raw_sql_.*, rownum raw_rnum_
+                  FROM ("
+
+            collector = super(o, collector)
+
+            if offset.expr.is_a? Nodes::BindParam
+              collector << ") raw_sql_ WHERE rownum <= ("
+              collector = visit offset.expr, collector
+              collector << " + "
+              collector = visit limit, collector
+              collector << ") ) WHERE raw_rnum_ > "
+              collector = visit offset.expr, collector
+              return collector
+            else
+              collector << ") raw_sql_
+                  WHERE rownum <= #{offset.expr.to_i + limit}
+                )
+                WHERE "
+              return visit(offset, collector)
+            end
+          end
+
+          if o.limit
+            o       = o.dup
+            limit   = o.limit.expr
+            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
+            collector << "SELECT * FROM (
+                  SELECT raw_sql_.*, rownum raw_rnum_
+                  FROM ("
+            collector = super(o, collector)
+            collector << ") raw_sql_
+                )
+                WHERE "
+            return visit offset, collector
+          end
+
+          super
+        end
+
+        def visit_Arel_Nodes_Limit(o, collector)
+          collector
+        end
+
+        def visit_Arel_Nodes_Offset(o, collector)
+          collector << "raw_rnum_ > "
+          visit o.expr, collector
+        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
+
+        ###
+        # Hacks for the order clauses specific to Oracle
+        def order_hacks(o)
+          return o if o.orders.empty?
+          return o unless o.cores.any? do |core|
+            core.projections.any? do |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 do |x|
+            string = visit(x, Arel::Collectors::SQLString.new).value
+            if string.include?(",")
+              split_order_string(string)
+            else
+              string
+            end
+          end.flatten
+          o.orders = []
+          orders.each_with_index do |order, i|
+            o.orders <<
+              Nodes::SqlLiteral.new("alias_#{i}__#{' DESC' if /\bdesc$/i === order}")
+          end
+          o
+        end
+
+        # Split string by commas but count opening and closing brackets
+        # and ignore commas inside brackets.
+        def split_order_string(string)
+          array = []
+          i = 0
+          string.split(",").each do |part|
+            if array[i]
+              array[i] << "," << part
+            else
+              # to ensure that array[i] will be String and not Arel::Nodes::SqlLiteral
+              array[i] = part.to_s
+            end
+            i += 1 if array[i].count("(") == array[i].count(")")
+          end
+          array
+        end
+
+        def visit_Arel_Nodes_BindParam(o, collector)
+          collector.add_bind(o.value) { |i| ":a#{i}" }
+        end
+
+        def is_distinct_from(o, collector)
+          collector << "DECODE("
+          collector = visit [o.left, o.right, 0, 1], collector
+          collector << ")"
+        end
+    end
+  end
+end

data/lib/arel/visitors/oracle12.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  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
+          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.value) { |i| ":a#{i}" }
+        end
+
+        def is_distinct_from(o, collector)
+          collector << "DECODE("
+          collector = visit [o.left, o.right, 0, 1], collector
+          collector << ")"
+        end
+    end
+  end
+end

data/lib/arel/visitors/postgresql.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+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)
+          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)
+          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)
+          op = o.case_sensitive ? " ~ " : " ~* "
+          infix_value o, collector, op
+        end
+
+        def visit_Arel_Nodes_NotRegexp(o, collector)
+          op = o.case_sensitive ? " !~ " : " !~* "
+          infix_value o, collector, op
+        end
+
+        def visit_Arel_Nodes_DistinctOn(o, collector)
+          collector << "DISTINCT ON ( "
+          visit(o.expr, collector) << " )"
+        end
+
+        def visit_Arel_Nodes_BindParam(o, collector)
+          collector.add_bind(o.value) { |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_SETS
+          grouping_array_or_grouping_element o, collector
+        end
+
+        def visit_Arel_Nodes_Lateral(o, collector)
+          collector << LATERAL
+          collector << SPACE
+          grouping_parentheses o, collector
+        end
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS NOT DISTINCT FROM "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS DISTINCT FROM "
+          visit o.right, collector
+        end
+
+        # Used by Lateral visitor to enclose select queries in parentheses
+        def grouping_parentheses(o, collector)
+          if o.expr.is_a? Nodes::SelectStatement
+            collector << "("
+            visit o.expr, collector
+            collector << ")"
+          else
+            visit o.expr, collector
+          end
+        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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class SQLite < Arel::Visitors::ToSql
+      private
+
+        # Locks are not supported in SQLite
+        def visit_Arel_Nodes_Lock(o, collector)
+          collector
+        end
+
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          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
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " IS NOT "
+          visit o.right, collector
+        end
+    end
+  end
+end