activerecord 6.0.1 → 6.1.7.2

data/lib/active_record/railties/collection_cache_association_loading.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  module Railties # :nodoc:
-    module CollectionCacheAssociationLoading #:nodoc:
-      def setup(context, options, as, block)
-        @relation = relation_from_options(options)
-
-        super
-      end
-
-      def relation_from_options(cached: nil, partial: nil, collection: nil, **_)
-        return unless cached
-
-        relation = partial if partial.is_a?(ActiveRecord::Relation)
-        relation ||= collection if collection.is_a?(ActiveRecord::Relation)
-
-        if relation && !relation.loaded?
-          relation.skip_preloading!
-        end
-      end
-
-      def collection_without_template(*)
-        @relation.preload_associations(@collection) if @relation
-        super
-      end
-
-      def collection_with_template(*)
-        @relation.preload_associations(@collection) if @relation
-        super
-      end
-    end
-  end
-end

data/lib/active_record/relation/predicate_builder/base_handler.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class PredicateBuilder
-    class BaseHandler # :nodoc:
-      def initialize(predicate_builder)
-        @predicate_builder = predicate_builder
-      end
-
-      def call(attribute, value)
-        predicate_builder.build(attribute, value.id)
-      end
-
-      private
-        attr_reader :predicate_builder
-    end
-  end
-end

data/lib/active_record/relation/where_clause_factory.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class Relation
-    class WhereClauseFactory # :nodoc:
-      def initialize(klass, predicate_builder)
-        @klass = klass
-        @predicate_builder = predicate_builder
-      end
-
-      def build(opts, other)
-        case opts
-        when String, Array
-          parts = [klass.sanitize_sql(other.empty? ? opts : ([opts] + other))]
-        when Hash
-          attributes = predicate_builder.resolve_column_aliases(opts)
-          attributes.stringify_keys!
-
-          parts = predicate_builder.build_from_hash(attributes)
-        when Arel::Nodes::Node
-          parts = [opts]
-        else
-          raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
-        end
-
-        WhereClause.new(parts)
-      end
-
-      private
-        attr_reader :klass, :predicate_builder
-    end
-  end
-end

data/lib/arel/attributes.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "arel/attributes/attribute"
-
-module Arel # :nodoc: all
-  module Attributes
-    ###
-    # Factory method to wrap a raw database +column+ to an Arel Attribute.
-    def self.for(column)
-      case column.type
-      when :string, :text, :binary             then String
-      when :integer                            then Integer
-      when :float                              then Float
-      when :decimal                            then Decimal
-      when :date, :datetime, :timestamp, :time then Time
-      when :boolean                            then Boolean
-      else
-        Undefined
-      end
-    end
-  end
-end

data/lib/arel/visitors/depth_first.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-module Arel # :nodoc: all
-  module Visitors
-    class DepthFirst < Arel::Visitors::Visitor
-      def initialize(block = nil)
-        @block = block || Proc.new
-        super()
-      end
-
-      private
-
-        def visit(o, _ = nil)
-          super
-          @block.call o
-        end
-
-        def unary(o)
-          visit o.expr
-        end
-        alias :visit_Arel_Nodes_Else              :unary
-        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_Lateral           :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_Ordering          :unary
-        alias :visit_Arel_Nodes_Ascending         :unary
-        alias :visit_Arel_Nodes_Descending        :unary
-        alias :visit_Arel_Nodes_UnqualifiedColumn :unary
-        alias :visit_Arel_Nodes_OptimizerHints    :unary
-        alias :visit_Arel_Nodes_ValuesList        :unary
-
-        def function(o)
-          visit o.expressions
-          visit o.alias
-          visit o.distinct
-        end
-        alias :visit_Arel_Nodes_Avg    :function
-        alias :visit_Arel_Nodes_Exists :function
-        alias :visit_Arel_Nodes_Max    :function
-        alias :visit_Arel_Nodes_Min    :function
-        alias :visit_Arel_Nodes_Sum    :function
-
-        def visit_Arel_Nodes_NamedFunction(o)
-          visit o.name
-          visit o.expressions
-          visit o.distinct
-          visit o.alias
-        end
-
-        def visit_Arel_Nodes_Count(o)
-          visit o.expressions
-          visit o.alias
-          visit o.distinct
-        end
-
-        def visit_Arel_Nodes_Case(o)
-          visit o.case
-          visit o.conditions
-          visit o.default
-        end
-
-        def nary(o)
-          o.children.each { |child| visit child }
-        end
-        alias :visit_Arel_Nodes_And :nary
-
-        def binary(o)
-          visit o.left
-          visit 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_DeleteStatement    :binary
-        alias :visit_Arel_Nodes_DoesNotMatch       :binary
-        alias :visit_Arel_Nodes_Equality           :binary
-        alias :visit_Arel_Nodes_FullOuterJoin      :binary
-        alias :visit_Arel_Nodes_GreaterThan        :binary
-        alias :visit_Arel_Nodes_GreaterThanOrEqual :binary
-        alias :visit_Arel_Nodes_In                 :binary
-        alias :visit_Arel_Nodes_InfixOperation     :binary
-        alias :visit_Arel_Nodes_JoinSource         :binary
-        alias :visit_Arel_Nodes_InnerJoin          :binary
-        alias :visit_Arel_Nodes_LessThan           :binary
-        alias :visit_Arel_Nodes_LessThanOrEqual    :binary
-        alias :visit_Arel_Nodes_Matches            :binary
-        alias :visit_Arel_Nodes_NotEqual           :binary
-        alias :visit_Arel_Nodes_NotIn              :binary
-        alias :visit_Arel_Nodes_NotRegexp          :binary
-        alias :visit_Arel_Nodes_IsNotDistinctFrom  :binary
-        alias :visit_Arel_Nodes_IsDistinctFrom     :binary
-        alias :visit_Arel_Nodes_Or                 :binary
-        alias :visit_Arel_Nodes_OuterJoin          :binary
-        alias :visit_Arel_Nodes_Regexp             :binary
-        alias :visit_Arel_Nodes_RightOuterJoin     :binary
-        alias :visit_Arel_Nodes_TableAlias         :binary
-        alias :visit_Arel_Nodes_When               :binary
-
-        def visit_Arel_Nodes_StringJoin(o)
-          visit o.left
-        end
-
-        def visit_Arel_Attribute(o)
-          visit o.relation
-          visit 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
-        alias :visit_Arel_Attributes_Decimal :visit_Arel_Attribute
-
-        def visit_Arel_Table(o)
-          visit o.name
-        end
-
-        def terminal(o)
-        end
-        alias :visit_ActiveSupport_Multibyte_Chars :terminal
-        alias :visit_ActiveSupport_StringInquirer  :terminal
-        alias :visit_Arel_Nodes_Lock               :terminal
-        alias :visit_Arel_Nodes_Node               :terminal
-        alias :visit_Arel_Nodes_SqlLiteral         :terminal
-        alias :visit_Arel_Nodes_BindParam          :terminal
-        alias :visit_Arel_Nodes_Window             :terminal
-        alias :visit_Arel_Nodes_True               :terminal
-        alias :visit_Arel_Nodes_False              :terminal
-        alias :visit_BigDecimal                    :terminal
-        alias :visit_Class                         :terminal
-        alias :visit_Date                          :terminal
-        alias :visit_DateTime                      :terminal
-        alias :visit_FalseClass                    :terminal
-        alias :visit_Float                         :terminal
-        alias :visit_Integer                       :terminal
-        alias :visit_NilClass                      :terminal
-        alias :visit_String                        :terminal
-        alias :visit_Symbol                        :terminal
-        alias :visit_Time                          :terminal
-        alias :visit_TrueClass                     :terminal
-
-        def visit_Arel_Nodes_InsertStatement(o)
-          visit o.relation
-          visit o.columns
-          visit o.values
-        end
-
-        def visit_Arel_Nodes_SelectCore(o)
-          visit o.projections
-          visit o.source
-          visit o.wheres
-          visit o.groups
-          visit o.windows
-          visit o.havings
-        end
-
-        def visit_Arel_Nodes_SelectStatement(o)
-          visit o.cores
-          visit o.orders
-          visit o.limit
-          visit o.lock
-          visit o.offset
-        end
-
-        def visit_Arel_Nodes_UpdateStatement(o)
-          visit o.relation
-          visit o.values
-          visit o.wheres
-          visit o.orders
-          visit o.limit
-        end
-
-        def visit_Arel_Nodes_Comment(o)
-          visit o.values
-        end
-
-        def visit_Array(o)
-          o.each { |i| visit i }
-        end
-        alias :visit_Set :visit_Array
-
-        def visit_Hash(o)
-          o.each { |k, v| visit(k); visit(v) }
-        end
-
-        DISPATCH = dispatch_cache
-
-        def get_dispatch_cache
-          DISPATCH
-        end
-    end
-  end
-end

data/lib/arel/visitors/ibm_db.rb

@@ -1,34 +0,0 @@
-# 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

@@ -1,62 +0,0 @@
-# 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

@@ -1,157 +0,0 @@
-# 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