activerecord 5.2.4.3 → 6.0.0

data/lib/arel/visitors/ibm_db.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+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 "
+          collector = visit o.expr, collector
+          collector << " ROWS ONLY"
+        end
+
+        def is_distinct_from(o, collector)
+          collector << "DECODE("
+          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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Informix < Arel::Visitors::ToSql
+      private
+        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
+          maybe_visit o.lock, collector
+        end
+
+        def visit_Arel_Nodes_SelectCore(o, collector)
+          collector = inject_join o.projections, collector, ", "
+          if o.source && !o.source.empty?
+            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
+
+          if o.havings.any?
+            collector << " HAVING "
+            collector = inject_join o.havings, collector, " AND "
+          end
+          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
+          collector << " "
+        end
+    end
+  end
+end

data/lib/arel/visitors/mssql.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class MSSQL < Arel::Visitors::ToSql
+      RowNumber = Struct.new :children
+
+      def initialize(*)
+        @primary_keys = {}
+        super
+      end
+
+      private
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          right = o.right
+
+          if right.nil?
+            collector = visit o.left, collector
+            collector << " IS NULL"
+          else
+            collector << "EXISTS (VALUES ("
+            collector = visit o.left, collector
+            collector << ") INTERSECT VALUES ("
+            collector = visit right, collector
+            collector << "))"
+          end
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          if o.right.nil?
+            collector = visit o.left, collector
+            collector << " IS NOT NULL"
+          else
+            collector << "NOT "
+            visit_Arel_Nodes_IsNotDistinctFrom o, collector
+          end
+        end
+
+        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
+          end
+
+          is_select_count = false
+          o.cores.each { |x|
+            core_order_by = row_num_literal determine_order_by(o.orders, x)
+            if select_count? x
+              x.projections = [core_order_by]
+              is_select_count = true
+            else
+              x.projections << core_order_by
+            end
+          }
+
+          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)}"
+
+          if is_select_count
+            collector << ") AS subquery"
+          else
+            collector
+          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
+          if last_row
+            " _row_num BETWEEN #{first_row} AND #{last_row}"
+          else
+            " _row_num >= #{first_row}"
+          end
+        end
+
+        def visit_Arel_Nodes_DeleteStatement(o, collector)
+          collector << "DELETE "
+          if o.limit
+            collector << "TOP ("
+            visit o.limit.expr, collector
+            collector << ") "
+          end
+          collector << "FROM "
+          collector = visit o.relation, collector
+          if o.wheres.any?
+            collector << " WHERE "
+            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
+          elsif x.groups.any?
+            x.groups
+          else
+            pk = find_left_table_pk(x.froms)
+            pk ? [pk] : []
+          end
+        end
+
+        def row_num_literal(order_by)
+          RowNumber.new order_by
+        end
+
+        def select_count?(x)
+          x.projections.length == 1 && Arel::Nodes::Count === x.projections.first
+        end
+
+        # FIXME raise exception of there is no pk?
+        def find_left_table_pk(o)
+          if o.kind_of?(Arel::Nodes::Join)
+            find_left_table_pk(o.left)
+          elsif o.instance_of?(Arel::Table)
+            find_primary_key(o)
+          end
+        end
+
+        def find_primary_key(o)
+          @primary_keys[o.name] ||= begin
+            primary_key_name = @connection.primary_key(o.name)
+            # some tables might be without primary key
+            primary_key_name && o[primary_key_name]
+          end
+        end
+    end
+  end
+end

data/lib/arel/visitors/mysql.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class MySQL < Arel::Visitors::ToSql
+      private
+        def visit_Arel_Nodes_Bin(o, collector)
+          collector << "BINARY "
+          visit o.expr, collector
+        end
+
+        def visit_Arel_Nodes_UnqualifiedColumn(o, collector)
+          visit o.expr, collector
+        end
+
+        ###
+        # :'(
+        # http://dev.mysql.com/doc/refman/5.0/en/select.html#id3482214
+        def visit_Arel_Nodes_SelectStatement(o, collector)
+          if o.offset && !o.limit
+            o.limit = Arel::Nodes::Limit.new(18446744073709551615)
+          end
+          super
+        end
+
+        def visit_Arel_Nodes_SelectCore(o, collector)
+          o.froms ||= Arel.sql("DUAL")
+          super
+        end
+
+        def visit_Arel_Nodes_Concat(o, collector)
+          collector << " CONCAT("
+          visit o.left, collector
+          collector << ", "
+          visit o.right, collector
+          collector << ") "
+          collector
+        end
+
+        def visit_Arel_Nodes_IsNotDistinctFrom(o, collector)
+          collector = visit o.left, collector
+          collector << " <=> "
+          visit o.right, collector
+        end
+
+        def visit_Arel_Nodes_IsDistinctFrom(o, collector)
+          collector << "NOT "
+          visit_Arel_Nodes_IsNotDistinctFrom o, collector
+        end
+
+        # In the simple case, MySQL allows us to place JOINs directly into the UPDATE
+        # query. However, this does not allow for LIMIT, OFFSET and ORDER. To support
+        # these, we must use a subquery.
+        def prepare_update_statement(o)
+          if o.offset || has_join_sources?(o) && has_limit_or_offset_or_orders?(o)
+            super
+          else
+            o
+          end
+        end
+        alias :prepare_delete_statement :prepare_update_statement
+
+        # MySQL is too stupid to create a temporary table for use subquery, so we have
+        # to give it some prompting in the form of a subsubquery.
+        def build_subselect(key, o)
+          subselect = super
+
+          # Materialize subquery by adding distinct
+          # to work with MySQL 5.7.6 which sets optimizer_switch='derived_merge=on'
+          unless has_limit_or_offset_or_orders?(subselect)
+            core = subselect.cores.last
+            core.set_quantifier = Arel::Nodes::Distinct.new
+          end
+
+          Nodes::SelectStatement.new.tap do |stmt|
+            core = stmt.cores.last
+            core.froms = Nodes::Grouping.new(subselect).as("__active_record_temp")
+            core.projections = [Arel.sql(quote_column_name(key.name))]
+          end
+        end
+    end
+  end
+end

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