activerecord 4.2.11.1 → 6.0.3.5

data/lib/active_record/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
   def self.gem_version
@@ -5,10 +7,10 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 4
-    MINOR = 2
-    TINY  = 11
-    PRE   = "1"
+    MAJOR = 6
+    MINOR = 0
+    TINY  = 3
+    PRE   = "5"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/hash/indifferent_access'
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
   # == Single table inheritance
@@ -19,7 +21,7 @@ module ActiveRecord
   # Be aware that because the type column is an attribute on the record every new
   # subclass will instantly be marked as dirty and the type column will be included
   # in the list of changed attributes on the record. This is different from non
-  # STI classes:
+  # Single Table Inheritance(STI) classes:
   #
   #   Company.new.changed? # => false
   #   Firm.new.changed?    # => true
@@ -30,33 +32,40 @@ module ActiveRecord
   # for differentiating between them or reloading the right type with find.
   #
   # Note, all the attributes for all the cases are kept in the same table. Read more:
-  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  # https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
   #
   module Inheritance
     extend ActiveSupport::Concern
 
     included do
       # Determines whether to store the full constant name including namespace when using STI.
-      class_attribute :store_full_sti_class, instance_writer: false
-      self.store_full_sti_class = true
+      # This is true, by default.
+      class_attribute :store_full_sti_class, instance_writer: false, default: true
     end
 
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
       # instance of the given subclass instead of the base class.
-      def new(*args, &block)
+      def new(attributes = nil, &block)
         if abstract_class? || self == Base
           raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
-        attrs = args.first
-        if subclass_from_attributes?(attrs)
-          subclass = subclass_from_attributes(attrs)
+        if has_attribute?(inheritance_column)
+          subclass = subclass_from_attributes(attributes)
+
+          if subclass.nil? && scope_attributes = current_scope&.scope_for_create
+            subclass = subclass_from_attributes(scope_attributes)
+          end
+
+          if subclass.nil? && base_class?
+            subclass = subclass_from_attributes(column_defaults)
+          end
         end
 
-        if subclass
-          subclass.new(*args, &block)
+        if subclass && subclass != self
+          subclass.new(attributes, &block)
         else
           super
         end
@@ -79,20 +88,10 @@ module ActiveRecord
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
 
-      def symbolized_base_class
-        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_base_class` is deprecated and will be removed without replacement.')
-        @symbolized_base_class ||= base_class.to_s.to_sym
-      end
-
-      def symbolized_sti_name
-        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_sti_name` is deprecated and will be removed without replacement.')
-        @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
-      end
-
       # Returns the class descending directly from ActiveRecord::Base, or
       # an abstract class, if any, in the inheritance hierarchy.
       #
-      # If A extends AR::Base, A.base_class will return A. If B descends from A
+      # If A extends ActiveRecord::Base, A.base_class will return A. If B descends from A
       # through some arbitrarily deep hierarchy, B.base_class will return A.
       #
       # If B < A and C < B and if A is an abstract_class then both B.base_class
@@ -109,21 +108,53 @@ module ActiveRecord
         end
       end
 
-      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
-      # If you are using inheritance with ActiveRecord and don't want child classes
-      # to utilize the implied STI table name of the parent class, this will need to be true.
-      # For example, given the following:
+      # Returns whether the class is a base class.
+      # See #base_class for more information.
+      def base_class?
+        base_class == self
+      end
+
+      # Set this to +true+ if this is an abstract class (see
+      # <tt>abstract_class?</tt>).
+      # If you are using inheritance with Active Record and don't want a class
+      # to be considered as part of the STI hierarchy, you must set this to
+      # true.
+      # +ApplicationRecord+, for example, is generated as an abstract class.
+      #
+      # Consider the following default behaviour:
+      #
+      #   Shape = Class.new(ActiveRecord::Base)
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
       #
-      #   class SuperClass < ActiveRecord::Base
+      #   Shape.table_name   # => "shapes"
+      #   Polygon.table_name # => "shapes"
+      #   Square.table_name  # => "shapes"
+      #   Shape.create!      # => #<Shape id: 1, type: nil>
+      #   Polygon.create!    # => #<Polygon id: 2, type: "Polygon">
+      #   Square.create!     # => #<Square id: 3, type: "Square">
+      #
+      # However, when using <tt>abstract_class</tt>, +Shape+ is omitted from
+      # the hierarchy:
+      #
+      #   class Shape < ActiveRecord::Base
       #     self.abstract_class = true
       #   end
-      #   class Child < SuperClass
-      #     self.table_name = 'the_table_i_really_want'
-      #   end
-      #
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
       #
-      # <tt>self.abstract_class = true</tt> is required to make <tt>Child<.find,.create, or any Arel method></tt> use <tt>the_table_i_really_want</tt> instead of a table called <tt>super_classes</tt>
+      #   Shape.table_name   # => nil
+      #   Polygon.table_name # => "polygons"
+      #   Square.table_name  # => "polygons"
+      #   Shape.create!      # => NotImplementedError: Shape is an abstract class and cannot be instantiated.
+      #   Polygon.create!    # => #<Polygon id: 1, type: nil>
+      #   Square.create!     # => #<Square id: 2, type: "Square">
       #
+      # Note that in the above example, to disallow the creation of a plain
+      # +Polygon+, you should use <tt>validates :type, presence: true</tt>,
+      # instead of setting it as an abstract class. This way, +Polygon+ will
+      # stay in the hierarchy, and Active Record will continue to correctly
+      # derive the table name.
       attr_accessor :abstract_class
 
       # Returns whether this class is an abstract class or not.
@@ -135,89 +166,102 @@ module ActiveRecord
         store_full_sti_class ? name : name.demodulize
       end
 
-      protected
+      def polymorphic_name
+        base_class.name
+      end
 
-      # Returns the class type of the record using the current module as a prefix. So descendants of
-      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
-      def compute_type(type_name)
-        if type_name.match(/^::/)
-          # If the type is prefixed with a scope operator then we assume that
-          # the type_name is an absolute reference.
-          ActiveSupport::Dependencies.constantize(type_name)
-        else
-          # Build a list of candidates to search for
-          candidates = []
-          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
-          candidates << type_name
-
-          candidates.each do |candidate|
-            constant = ActiveSupport::Dependencies.safe_constantize(candidate)
-            return constant if candidate == constant.to_s
-          end
+      def inherited(subclass)
+        subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+        super
+      end
 
-          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+      protected
+        # Returns the class type of the record using the current module as a prefix. So descendants of
+        # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+        def compute_type(type_name)
+          if type_name.start_with?("::")
+            # If the type is prefixed with a scope operator then we assume that
+            # the type_name is an absolute reference.
+            ActiveSupport::Dependencies.constantize(type_name)
+          else
+            type_candidate = @_type_candidates_cache[type_name]
+            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+              return type_constant
+            end
+
+            # Build a list of candidates to search for
+            candidates = []
+            name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+            candidates << type_name
+
+            candidates.each do |candidate|
+              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              if candidate == constant.to_s
+                @_type_candidates_cache[type_name] = candidate
+                return constant
+              end
+            end
+
+            raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+          end
         end
-      end
 
       private
-
-      # Called by +instantiate+ to decide which class to use for a new
-      # record instance. For single-table inheritance, we check the record
-      # for a +type+ column and return the corresponding class.
-      def discriminate_class_for_record(record)
-        if using_single_table_inheritance?(record)
-          find_sti_class(record[inheritance_column])
-        else
-          super
+        # Called by +instantiate+ to decide which class to use for a new
+        # record instance. For single-table inheritance, we check the record
+        # for a +type+ column and return the corresponding class.
+        def discriminate_class_for_record(record)
+          if using_single_table_inheritance?(record)
+            find_sti_class(record[inheritance_column])
+          else
+            super
+          end
         end
-      end
 
-      def using_single_table_inheritance?(record)
-        record[inheritance_column].present? && columns_hash.include?(inheritance_column)
-      end
-
-      def find_sti_class(type_name)
-        if store_full_sti_class
-          ActiveSupport::Dependencies.constantize(type_name)
-        else
-          compute_type(type_name)
+        def using_single_table_inheritance?(record)
+          record[inheritance_column].present? && has_attribute?(inheritance_column)
         end
-      rescue NameError
-        raise SubclassNotFound,
-          "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
-          "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
-          "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
-          "or overwrite #{name}.inheritance_column to use another column for that information."
-      end
-
-      def type_condition(table = arel_table)
-        sti_column = table[inheritance_column]
-        sti_names  = ([self] + descendants).map { |model| model.sti_name }
 
-        sti_column.in(sti_names)
-      end
+        def find_sti_class(type_name)
+          type_name = base_class.type_for_attribute(inheritance_column).cast(type_name)
+          subclass = begin
+            if store_full_sti_class
+              ActiveSupport::Dependencies.constantize(type_name)
+            else
+              compute_type(type_name)
+            end
+          rescue NameError
+            raise SubclassNotFound,
+              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
+              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
+              "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
+              "or overwrite #{name}.inheritance_column to use another column for that information."
+          end
+          unless subclass == self || descendants.include?(subclass)
+            raise SubclassNotFound, "Invalid single-table inheritance type: #{subclass.name} is not a subclass of #{name}"
+          end
+          subclass
+        end
 
-      # Detect the subclass from the inheritance column of attrs. If the inheritance column value
-      # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
-      # If this is a StrongParameters hash, and access to inheritance_column is not permitted,
-      # this will ignore the inheritance column and return nil
-      def subclass_from_attributes?(attrs)
-        columns_hash.include?(inheritance_column) && attrs.is_a?(Hash)
-      end
+        def type_condition(table = arel_table)
+          sti_column = arel_attribute(inheritance_column, table)
+          sti_names  = ([self] + descendants).map(&:sti_name)
 
-      def subclass_from_attributes(attrs)
-        subclass_name = attrs.with_indifferent_access[inheritance_column]
+          predicate_builder.build(sti_column, sti_names)
+        end
 
-        if subclass_name.present? && subclass_name != self.name
-          subclass = subclass_name.safe_constantize
+        # Detect the subclass from the inheritance column of attrs. If the inheritance column value
+        # is not self or a valid subclass, raises ActiveRecord::SubclassNotFound
+        def subclass_from_attributes(attrs)
+          attrs = attrs.to_h if attrs.respond_to?(:permitted?)
+          if attrs.is_a?(Hash)
+            subclass_name = attrs[inheritance_column] || attrs[inheritance_column.to_sym]
 
-          unless descendants.include?(subclass)
-            raise ActiveRecord::SubclassNotFound.new("Invalid single-table inheritance type: #{subclass_name} is not a subclass of #{name}")
+            if subclass_name.present?
+              find_sti_class(subclass_name)
+            end
           end
-
-          subclass
         end
-      end
     end
 
     def initialize_dup(other)
@@ -226,22 +270,21 @@ module ActiveRecord
     end
 
     private
+      def initialize_internals_callback
+        super
+        ensure_proper_type
+      end
 
-    def initialize_internals_callback
-      super
-      ensure_proper_type
-    end
-
-    # Sets the attribute used for single table inheritance to this class name if this is not the
-    # ActiveRecord::Base descendant.
-    # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
-    # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
-    # No such attribute would be set for objects of the Message class in that example.
-    def ensure_proper_type
-      klass = self.class
-      if klass.finder_needs_type_condition?
-        write_attribute(klass.inheritance_column, klass.sti_name)
+      # Sets the attribute used for single table inheritance to this class name if this is not the
+      # ActiveRecord::Base descendant.
+      # Considering the hierarchy Reply < Message < ActiveRecord::Base, this makes it possible to
+      # do Reply.new without having to set <tt>Reply[Reply.inheritance_column] = "Reply"</tt> yourself.
+      # No such attribute would be set for objects of the Message class in that example.
+      def ensure_proper_type
+        klass = self.class
+        if klass.finder_needs_type_condition?
+          _write_attribute(klass.inheritance_column, klass.sti_name)
+        end
       end
-    end
   end
 end

data/lib/active_record/insert_all.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class InsertAll # :nodoc:
+    attr_reader :model, :connection, :inserts, :keys
+    attr_reader :on_duplicate, :returning, :unique_by
+
+    def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil)
+      raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
+
+      @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s).to_set
+      @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
+
+      @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
+      @returning = false if @returning == []
+
+      @unique_by = find_unique_index_for(unique_by) if unique_by
+      @on_duplicate = :skip if @on_duplicate == :update && updatable_columns.empty?
+
+      ensure_valid_options_for_connection!
+    end
+
+    def execute
+      message = +"#{model} "
+      message << "Bulk " if inserts.many?
+      message << (on_duplicate == :update ? "Upsert" : "Insert")
+      connection.exec_insert_all to_sql, message
+    end
+
+    def updatable_columns
+      keys - readonly_columns - unique_by_columns
+    end
+
+    def primary_keys
+      Array(model.primary_key)
+    end
+
+
+    def skip_duplicates?
+      on_duplicate == :skip
+    end
+
+    def update_duplicates?
+      on_duplicate == :update
+    end
+
+    def map_key_with_value
+      inserts.map do |attributes|
+        attributes = attributes.stringify_keys
+        verify_attributes(attributes)
+
+        keys.map do |key|
+          yield key, attributes[key]
+        end
+      end
+    end
+
+    private
+      def find_unique_index_for(unique_by)
+        match = Array(unique_by).map(&:to_s)
+
+        if index = unique_indexes.find { |i| match.include?(i.name) || i.columns == match }
+          index
+        else
+          raise ArgumentError, "No unique index found for #{unique_by}"
+        end
+      end
+
+      def unique_indexes
+        connection.schema_cache.indexes(model.table_name).select(&:unique)
+      end
+
+
+      def ensure_valid_options_for_connection!
+        if returning && !connection.supports_insert_returning?
+          raise ArgumentError, "#{connection.class} does not support :returning"
+        end
+
+        if skip_duplicates? && !connection.supports_insert_on_duplicate_skip?
+          raise ArgumentError, "#{connection.class} does not support skipping duplicates"
+        end
+
+        if update_duplicates? && !connection.supports_insert_on_duplicate_update?
+          raise ArgumentError, "#{connection.class} does not support upsert"
+        end
+
+        if unique_by && !connection.supports_insert_conflict_target?
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
+      end
+
+
+      def to_sql
+        connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(self))
+      end
+
+
+      def readonly_columns
+        primary_keys + model.readonly_attributes.to_a
+      end
+
+      def unique_by_columns
+        Array(unique_by&.columns)
+      end
+
+
+      def verify_attributes(attributes)
+        if keys != attributes.keys.to_set
+          raise ArgumentError, "All objects being inserted must have the same keys"
+        end
+      end
+
+      class Builder # :nodoc:
+        attr_reader :model
+
+        delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all
+
+        def initialize(insert_all)
+          @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
+        end
+
+        def into
+          "INTO #{model.quoted_table_name} (#{columns_list})"
+        end
+
+        def values_list
+          types = extract_types_from_columns_on(model.table_name, keys: keys)
+
+          values_list = insert_all.map_key_with_value do |key, value|
+            connection.with_yaml_fallback(types[key].serialize(value))
+          end
+
+          connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
+        end
+
+        def returning
+          format_columns(insert_all.returning) if insert_all.returning
+        end
+
+        def conflict_target
+          if index = insert_all.unique_by
+            sql = +"(#{format_columns(index.columns)})"
+            sql << " WHERE #{index.where}" if index.where
+            sql
+          elsif update_duplicates?
+            "(#{format_columns(insert_all.primary_keys)})"
+          end
+        end
+
+        def updatable_columns
+          quote_columns(insert_all.updatable_columns)
+        end
+
+        private
+          attr_reader :connection, :insert_all
+
+          def columns_list
+            format_columns(insert_all.keys)
+          end
+
+          def extract_types_from_columns_on(table_name, keys:)
+            columns = connection.schema_cache.columns_hash(table_name)
+
+            unknown_column = (keys - columns.keys).first
+            raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column
+
+            keys.index_with { |key| model.type_for_attribute(key) }
+          end
+
+          def format_columns(columns)
+            quote_columns(columns).join(",")
+          end
+
+          def quote_columns(columns)
+            columns.map(&connection.method(:quote_column_name))
+          end
+      end
+  end
+end