activerecord 5.2.5 → 6.0.4.6

data/lib/arel/visitors/dot.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module Arel # :nodoc: all
+  module Visitors
+    class Dot < Arel::Visitors::Visitor
+      class Node # :nodoc:
+        attr_accessor :name, :id, :fields
+
+        def initialize(name, id, fields = [])
+          @name   = name
+          @id     = id
+          @fields = fields
+        end
+      end
+
+      class Edge < Struct.new :name, :from, :to # :nodoc:
+      end
+
+      def initialize
+        super()
+        @nodes      = []
+        @edges      = []
+        @node_stack = []
+        @edge_stack = []
+        @seen       = {}
+      end
+
+      def accept(object, collector)
+        visit object
+        collector << to_dot
+      end
+
+      private
+        def visit_Arel_Nodes_Ordering(o)
+          visit_edge o, "expr"
+        end
+
+        def visit_Arel_Nodes_TableAlias(o)
+          visit_edge o, "name"
+          visit_edge o, "relation"
+        end
+
+        def visit_Arel_Nodes_Count(o)
+          visit_edge o, "expressions"
+          visit_edge o, "distinct"
+        end
+
+        def visit_Arel_Nodes_ValuesList(o)
+          visit_edge o, "rows"
+        end
+
+        def visit_Arel_Nodes_StringJoin(o)
+          visit_edge o, "left"
+        end
+
+        def visit_Arel_Nodes_InnerJoin(o)
+          visit_edge o, "left"
+          visit_edge o, "right"
+        end
+        alias :visit_Arel_Nodes_FullOuterJoin  :visit_Arel_Nodes_InnerJoin
+        alias :visit_Arel_Nodes_OuterJoin      :visit_Arel_Nodes_InnerJoin
+        alias :visit_Arel_Nodes_RightOuterJoin :visit_Arel_Nodes_InnerJoin
+
+        def visit_Arel_Nodes_DeleteStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "wheres"
+        end
+
+        def unary(o)
+          visit_edge o, "expr"
+        end
+        alias :visit_Arel_Nodes_Group             :unary
+        alias :visit_Arel_Nodes_Cube              :unary
+        alias :visit_Arel_Nodes_RollUp            :unary
+        alias :visit_Arel_Nodes_GroupingSet       :unary
+        alias :visit_Arel_Nodes_GroupingElement   :unary
+        alias :visit_Arel_Nodes_Grouping          :unary
+        alias :visit_Arel_Nodes_Having            :unary
+        alias :visit_Arel_Nodes_Limit             :unary
+        alias :visit_Arel_Nodes_Not               :unary
+        alias :visit_Arel_Nodes_Offset            :unary
+        alias :visit_Arel_Nodes_On                :unary
+        alias :visit_Arel_Nodes_UnqualifiedColumn :unary
+        alias :visit_Arel_Nodes_OptimizerHints    :unary
+        alias :visit_Arel_Nodes_Preceding         :unary
+        alias :visit_Arel_Nodes_Following         :unary
+        alias :visit_Arel_Nodes_Rows              :unary
+        alias :visit_Arel_Nodes_Range             :unary
+
+        def window(o)
+          visit_edge o, "partitions"
+          visit_edge o, "orders"
+          visit_edge o, "framing"
+        end
+        alias :visit_Arel_Nodes_Window            :window
+
+        def named_window(o)
+          visit_edge o, "partitions"
+          visit_edge o, "orders"
+          visit_edge o, "framing"
+          visit_edge o, "name"
+        end
+        alias :visit_Arel_Nodes_NamedWindow       :named_window
+
+        def function(o)
+          visit_edge o, "expressions"
+          visit_edge o, "distinct"
+          visit_edge o, "alias"
+        end
+        alias :visit_Arel_Nodes_Exists :function
+        alias :visit_Arel_Nodes_Min    :function
+        alias :visit_Arel_Nodes_Max    :function
+        alias :visit_Arel_Nodes_Avg    :function
+        alias :visit_Arel_Nodes_Sum    :function
+
+        def extract(o)
+          visit_edge o, "expressions"
+          visit_edge o, "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"
+        end
+
+        def visit_Arel_Nodes_InsertStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "columns"
+          visit_edge o, "values"
+        end
+
+        def visit_Arel_Nodes_SelectCore(o)
+          visit_edge o, "source"
+          visit_edge o, "projections"
+          visit_edge o, "wheres"
+          visit_edge o,  "windows"
+        end
+
+        def visit_Arel_Nodes_SelectStatement(o)
+          visit_edge o, "cores"
+          visit_edge o, "limit"
+          visit_edge o, "orders"
+          visit_edge o, "offset"
+        end
+
+        def visit_Arel_Nodes_UpdateStatement(o)
+          visit_edge o, "relation"
+          visit_edge o, "wheres"
+          visit_edge o, "values"
+        end
+
+        def visit_Arel_Table(o)
+          visit_edge o, "name"
+        end
+
+        def visit_Arel_Nodes_Casted(o)
+          visit_edge o, "val"
+          visit_edge o, "attribute"
+        end
+
+        def visit_Arel_Attribute(o)
+          visit_edge o, "relation"
+          visit_edge o, "name"
+        end
+        alias :visit_Arel_Attributes_Integer :visit_Arel_Attribute
+        alias :visit_Arel_Attributes_Float :visit_Arel_Attribute
+        alias :visit_Arel_Attributes_String :visit_Arel_Attribute
+        alias :visit_Arel_Attributes_Time :visit_Arel_Attribute
+        alias :visit_Arel_Attributes_Boolean :visit_Arel_Attribute
+        alias :visit_Arel_Attributes_Attribute :visit_Arel_Attribute
+
+        def nary(o)
+          o.children.each_with_index do |x, i|
+            edge(i) { visit x }
+          end
+        end
+        alias :visit_Arel_Nodes_And :nary
+
+        def binary(o)
+          visit_edge o, "left"
+          visit_edge o, "right"
+        end
+        alias :visit_Arel_Nodes_As                 :binary
+        alias :visit_Arel_Nodes_Assignment         :binary
+        alias :visit_Arel_Nodes_Between            :binary
+        alias :visit_Arel_Nodes_Concat             :binary
+        alias :visit_Arel_Nodes_DoesNotMatch       :binary
+        alias :visit_Arel_Nodes_Equality           :binary
+        alias :visit_Arel_Nodes_GreaterThan        :binary
+        alias :visit_Arel_Nodes_GreaterThanOrEqual :binary
+        alias :visit_Arel_Nodes_In                 :binary
+        alias :visit_Arel_Nodes_JoinSource         :binary
+        alias :visit_Arel_Nodes_LessThan           :binary
+        alias :visit_Arel_Nodes_LessThanOrEqual    :binary
+        alias :visit_Arel_Nodes_IsNotDistinctFrom  :binary
+        alias :visit_Arel_Nodes_IsDistinctFrom     :binary
+        alias :visit_Arel_Nodes_Matches            :binary
+        alias :visit_Arel_Nodes_NotEqual           :binary
+        alias :visit_Arel_Nodes_NotIn              :binary
+        alias :visit_Arel_Nodes_Or                 :binary
+        alias :visit_Arel_Nodes_Over               :binary
+
+        def visit_String(o)
+          @node_stack.last.fields << o
+        end
+        alias :visit_Time :visit_String
+        alias :visit_Date :visit_String
+        alias :visit_DateTime :visit_String
+        alias :visit_NilClass :visit_String
+        alias :visit_TrueClass :visit_String
+        alias :visit_FalseClass :visit_String
+        alias :visit_Integer :visit_String
+        alias :visit_BigDecimal :visit_String
+        alias :visit_Float :visit_String
+        alias :visit_Symbol :visit_String
+        alias :visit_Arel_Nodes_SqlLiteral :visit_String
+
+        def visit_Arel_Nodes_BindParam(o); end
+
+        def visit_Hash(o)
+          o.each_with_index do |pair, i|
+            edge("pair_#{i}")   { visit pair }
+          end
+        end
+
+        def visit_Array(o)
+          o.each_with_index do |x, i|
+            edge(i) { visit x }
+          end
+        end
+        alias :visit_Set :visit_Array
+
+        def visit_Arel_Nodes_Comment(o)
+          visit_edge(o, "values")
+        end
+
+        def visit_edge(o, method)
+          edge(method) { visit o.send(method) }
+        end
+
+        def visit(o)
+          if node = @seen[o.object_id]
+            @edge_stack.last.to = node
+            return
+          end
+
+          node = Node.new(o.class.name, o.object_id)
+          @seen[node.id] = node
+          @nodes << node
+          with_node node do
+            super
+          end
+        end
+
+        def edge(name)
+          edge = Edge.new(name, @node_stack.last)
+          @edge_stack.push edge
+          @edges << edge
+          yield
+          @edge_stack.pop
+        end
+
+        def with_node(node)
+          if edge = @edge_stack.last
+            edge.to = node
+          end
+
+          @node_stack.push node
+          yield
+          @node_stack.pop
+        end
+
+        def quote(string)
+          string.to_s.gsub('"', '\"')
+        end
+
+        def to_dot
+          "digraph \"Arel\" {\nnode [width=0.375,height=0.25,shape=record];\n" +
+            @nodes.map { |node|
+              label = "<f0>#{node.name}"
+
+              node.fields.each_with_index do |field, i|
+                label += "|<f#{i + 1}>#{quote field}"
+              end
+
+              "#{node.id} [label=\"#{label}\"];"
+            }.join("\n") + "\n" + @edges.map { |edge|
+              "#{edge.from.id} -> #{edge.to.id} [label=\"#{edge.name}\"];"
+            }.join("\n") + "\n}"
+        end
+    end
+  end
+end

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,156 @@
+# 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