activerecord 5.0.7.2 → 6.1.1

data/lib/active_record/migration/join_table.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   class Migration
     module JoinTable #:nodoc:
       private
+        def find_join_table_name(table_1, table_2, options = {})
+          options.delete(:table_name) || join_table_name(table_1, table_2)
+        end
 
-      def find_join_table_name(table_1, table_2, options = {})
-        options.delete(:table_name) || join_table_name(table_1, table_2)
-      end
-
-      def join_table_name(table_1, table_2)
-        ModelSchema.derive_join_table_name(table_1, table_2).to_sym
-      end
+        def join_table_name(table_1, table_2)
+          ModelSchema.derive_join_table_name(table_1, table_2).to_sym
+        end
     end
   end
 end

data/lib/active_record/model_schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "monitor"
 
 module ActiveRecord
@@ -84,19 +86,6 @@ module ActiveRecord
     #
     # Sets the name of the internal metadata table.
 
-    ##
-    # :singleton-method: protected_environments
-    # :call-seq: protected_environments
-    #
-    # The array of names of environments where destructive actions should be prohibited. By default,
-    # the value is <tt>["production"]</tt>.
-
-    ##
-    # :singleton-method: protected_environments=
-    # :call-seq: protected_environments=(environments)
-    #
-    # Sets an array of names of environments where destructive actions should be prohibited.
-
     ##
     # :singleton-method: pluralize_table_names
     # :call-seq: pluralize_table_names
@@ -113,31 +102,46 @@ module ActiveRecord
     # If true, the default table name for a Product class will be "products". If false, it would just be "product".
     # See table_name for the full rules on table/class naming. This is true, by default.
 
-    included do
-      mattr_accessor :primary_key_prefix_type, instance_writer: false
+    ##
+    # :singleton-method: implicit_order_column
+    # :call-seq: implicit_order_column
+    #
+    # The name of the column records are ordered by if no explicit order clause
+    # is used during an ordered finder call. If not set the primary key is used.
 
-      class_attribute :table_name_prefix, instance_writer: false
-      self.table_name_prefix = ""
+    ##
+    # :singleton-method: implicit_order_column=
+    # :call-seq: implicit_order_column=(column_name)
+    #
+    # Sets the column to sort records by when no explicit order clause is used
+    # during an ordered finder call. Useful when the primary key is not an
+    # auto-incrementing integer, for example when it's a UUID. Records are subsorted
+    # by the primary key if it exists to ensure deterministic results.
 
-      class_attribute :table_name_suffix, instance_writer: false
-      self.table_name_suffix = ""
+    ##
+    # :singleton-method: immutable_strings_by_default=
+    # :call-seq: immutable_strings_by_default=(bool)
+    #
+    # Determines whether columns should infer their type as `:string` or
+    # `:immutable_string`. This setting does not affect the behavior of
+    # `attribute :foo, :string`. Defaults to false.
 
-      class_attribute :schema_migrations_table_name, instance_accessor: false
-      self.schema_migrations_table_name = "schema_migrations"
+    included do
+      mattr_accessor :primary_key_prefix_type, instance_writer: false
 
-      class_attribute :internal_metadata_table_name, instance_accessor: false
-      self.internal_metadata_table_name = "ar_internal_metadata"
+      class_attribute :table_name_prefix, instance_writer: false, default: ""
+      class_attribute :table_name_suffix, instance_writer: false, default: ""
+      class_attribute :schema_migrations_table_name, instance_accessor: false, default: "schema_migrations"
+      class_attribute :internal_metadata_table_name, instance_accessor: false, default: "ar_internal_metadata"
+      class_attribute :pluralize_table_names, instance_writer: false, default: true
+      class_attribute :implicit_order_column, instance_accessor: false
+      class_attribute :immutable_strings_by_default, instance_accessor: false
 
-      class_attribute :protected_environments, instance_accessor: false
       self.protected_environments = ["production"]
-
-      class_attribute :pluralize_table_names, instance_writer: false
-      self.pluralize_table_names = true
-
-      self.inheritance_column = 'type'
+      self.inheritance_column = "type"
       self.ignored_columns = [].freeze
 
-      delegate :type_for_attribute, to: :class
+      delegate :type_for_attribute, :column_for_attribute, to: :class
 
       initialize_load_schema_monitor
     end
@@ -240,11 +244,26 @@ module ActiveRecord
       end
 
       def full_table_name_prefix #:nodoc:
-        (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+        (module_parents.detect { |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
       end
 
       def full_table_name_suffix #:nodoc:
-        (parents.detect {|p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+        (module_parents.detect { |p| p.respond_to?(:table_name_suffix) } || self).table_name_suffix
+      end
+
+      # The array of names of environments where destructive actions should be prohibited. By default,
+      # the value is <tt>["production"]</tt>.
+      def protected_environments
+        if defined?(@protected_environments)
+          @protected_environments
+        else
+          superclass.protected_environments
+        end
+      end
+
+      # Sets an array of names of environments where destructive actions should be prohibited.
+      def protected_environments=(environments)
+        @protected_environments = environments.map(&:to_s)
       end
 
       # Defines the name of the table column which will store the class name on single-table
@@ -278,12 +297,42 @@ module ActiveRecord
 
       # Sets the columns names the model should ignore. Ignored columns won't have attribute
       # accessors defined, and won't be referenced in SQL queries.
+      #
+      # A common usage pattern for this method is to ensure all references to an attribute
+      # have been removed and deployed, before a migration to drop the column from the database
+      # has been deployed and run. Using this two step approach to dropping columns ensures there
+      # is no code that raises errors due to having a cached schema in memory at the time the
+      # schema migration is run.
+      #
+      # For example, given a model where you want to drop the "category" attribute, first mark it
+      # as ignored:
+      #
+      #   class Project < ActiveRecord::Base
+      #     # schema:
+      #     #   id         :bigint
+      #     #   name       :string, limit: 255
+      #     #   category   :string, limit: 255
+      #
+      #     self.ignored_columns = [:category]
+      #   end
+      #
+      # The schema still contains `category`, but now the model omits it, so any meta-driven code or
+      # schema caching will not attempt to use the column:
+      #
+      #   Project.columns_hash["category"] => nil
+      #
+      # You will get an error if accessing that attribute directly, so ensure all usages of the
+      # column are removed (automated tests can help you find any usages).
+      #
+      #   user = Project.create!(name: "First Project")
+      #   user.category # => raises NoMethodError
       def ignored_columns=(columns)
-        @ignored_columns = columns.map(&:to_s)
+        reload_schema_from_cache
+        @ignored_columns = columns.map(&:to_s).freeze
       end
 
       def sequence_name
-        if base_class == self
+        if base_class?
           @sequence_name ||= reset_sequence_name
         else
           (@sequence_name ||= nil) || base_class.sequence_name
@@ -296,7 +345,7 @@ module ActiveRecord
       end
 
       # Sets the name of the sequence to use when generating ids to the given
-      # value, or (if the value is nil or false) to the value returned by the
+      # value, or (if the value is +nil+ or +false+) to the value returned by the
       # given block. This is required for Oracle and is useful for any
       # database which relies on sequences for primary key generation.
       #
@@ -334,7 +383,7 @@ module ActiveRecord
       def attributes_builder # :nodoc:
         unless defined?(@attributes_builder) && @attributes_builder
           defaults = _default_attributes.except(*(column_names - [primary_key]))
-          @attributes_builder = AttributeSet::Builder.new(attribute_types, defaults)
+          @attributes_builder = ActiveModel::AttributeSet::Builder.new(attribute_types, defaults)
         end
         @attributes_builder
       end
@@ -346,12 +395,16 @@ module ActiveRecord
 
       def columns
         load_schema
-        @columns ||= columns_hash.values
+        @columns ||= columns_hash.values.freeze
       end
 
       def attribute_types # :nodoc:
         load_schema
-        @attribute_types ||= Hash.new(Type::Value.new)
+        @attribute_types ||= Hash.new(Type.default_value)
+      end
+
+      def yaml_encoder # :nodoc:
+        @yaml_encoder ||= ActiveModel::AttributeSet::YAMLEncoder.new(attribute_types)
       end
 
       # Returns the type of the attribute with the given name, after applying
@@ -364,8 +417,11 @@ module ActiveRecord
       # it).
       #
       # +attr_name+ The name of the attribute to retrieve the type for. Must be
-      # a string
+      # a string or a symbol.
       def type_for_attribute(attr_name, &block)
+        attr_name = attr_name.to_s
+        attr_name = attribute_aliases[attr_name] || attr_name
+
         if block
           attribute_types.fetch(attr_name, &block)
         else
@@ -373,26 +429,56 @@ module ActiveRecord
         end
       end
 
+      # Returns the column object for the named attribute.
+      # Returns an +ActiveRecord::ConnectionAdapters::NullColumn+ if the
+      # named attribute does not exist.
+      #
+      #   class Person < ActiveRecord::Base
+      #   end
+      #
+      #   person = Person.new
+      #   person.column_for_attribute(:name) # the result depends on the ConnectionAdapter
+      #   # => #<ActiveRecord::ConnectionAdapters::Column:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
+      #
+      #   person.column_for_attribute(:nothing)
+      #   # => #<ActiveRecord::ConnectionAdapters::NullColumn:0xXXX @name=nil, @sql_type=nil, @cast_type=#<Type::Value>, ...>
+      def column_for_attribute(name)
+        name = name.to_s
+        columns_hash.fetch(name) do
+          ConnectionAdapters::NullColumn.new(name)
+        end
+      end
+
       # Returns a hash where the keys are column names and the values are
       # default values when instantiating the Active Record object for this table.
       def column_defaults
         load_schema
-        _default_attributes.to_hash
+        @column_defaults ||= _default_attributes.deep_dup.to_hash.freeze
       end
 
       def _default_attributes # :nodoc:
-        @default_attributes ||= AttributeSet.new({})
+        load_schema
+        @default_attributes ||= ActiveModel::AttributeSet.new({})
       end
 
       # Returns an array of column names as strings.
       def column_names
-        @column_names ||= columns.map(&:name)
+        @column_names ||= columns.map(&:name).freeze
+      end
+
+      def symbol_column_to_string(name_symbol) # :nodoc:
+        @symbol_column_to_string_name_hash ||= column_names.index_by(&:to_sym)
+        @symbol_column_to_string_name_hash[name_symbol]
       end
 
       # Returns an array of column objects where the primary id, all columns ending in "_id" or "_count",
       # and columns used for single table inheritance have been removed.
       def content_columns
-        @content_columns ||= columns.reject { |c| c.name == primary_key || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
+        @content_columns ||= columns.reject do |c|
+          c.name == primary_key ||
+          c.name == inheritance_column ||
+          c.name.end_with?("_id", "_count")
+        end.freeze
       end
 
       # Resets all the cached information about columns, which will cause them
@@ -402,7 +488,7 @@ module ActiveRecord
       # when just after creating a table you want to populate it with some default
       # values, eg:
       #
-      #  class CreateJobLevels < ActiveRecord::Migration[5.0]
+      #  class CreateJobLevels < ActiveRecord::Migration[6.0]
       #    def up
       #      create_table :job_levels do |t|
       #        t.integer :id
@@ -423,7 +509,7 @@ module ActiveRecord
       #  end
       def reset_column_information
         connection.clear_cache!
-        undefine_attribute_methods
+        ([self] + descendants).each(&:undefine_attribute_methods)
         connection.schema_cache.clear_data_source_cache!(table_name)
 
         reload_schema_from_cache
@@ -431,109 +517,131 @@ module ActiveRecord
       end
 
       protected
-
-      def initialize_load_schema_monitor
-        @load_schema_monitor = Monitor.new
-      end
+        def initialize_load_schema_monitor
+          @load_schema_monitor = Monitor.new
+        end
 
       private
+        def inherited(child_class)
+          super
+          child_class.initialize_load_schema_monitor
+        end
 
-      def inherited(child_class)
-        super
-        child_class.initialize_load_schema_monitor
-      end
-
-      def schema_loaded?
-        defined?(@schema_loaded) && @schema_loaded
-      end
+        def schema_loaded?
+          defined?(@schema_loaded) && @schema_loaded
+        end
 
-      def load_schema
-        return if schema_loaded?
-        @load_schema_monitor.synchronize do
-          return if defined?(@columns_hash) && @columns_hash
+        def load_schema
+          return if schema_loaded?
+          @load_schema_monitor.synchronize do
+            return if defined?(@columns_hash) && @columns_hash
 
-          load_schema!
+            load_schema!
 
-          @schema_loaded = true
+            @schema_loaded = true
+          rescue
+            reload_schema_from_cache # If the schema loading failed half way through, we must reset the state.
+            raise
+          end
         end
-      end
 
-      def load_schema!
-        @columns_hash = connection.schema_cache.columns_hash(table_name).except(*ignored_columns)
-        @columns_hash.each do |name, column|
-          warn_if_deprecated_type(column)
-          define_attribute(
-            name,
-            connection.lookup_cast_type_from_column(column),
-            default: column.default,
-            user_provided_default: false
-          )
+        def load_schema!
+          unless table_name
+            raise ActiveRecord::TableNotSpecified, "#{self} has no table configured. Set one with #{self}.table_name="
+          end
+
+          columns_hash = connection.schema_cache.columns_hash(table_name)
+          columns_hash = columns_hash.except(*ignored_columns) unless ignored_columns.empty?
+          @columns_hash = columns_hash.freeze
+          @columns_hash.each do |name, column|
+            type = connection.lookup_cast_type_from_column(column)
+            type = _convert_type_from_options(type)
+            warn_if_deprecated_type(column)
+            define_attribute(
+              name,
+              type,
+              default: column.default,
+              user_provided_default: false
+            )
+          end
         end
-      end
 
-      def reload_schema_from_cache
-        @arel_engine = nil
-        @arel_table = nil
-        @column_names = nil
-        @attribute_types = nil
-        @content_columns = nil
-        @default_attributes = nil
-        @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
-        @attributes_builder = nil
-        @columns = nil
-        @columns_hash = nil
-        @schema_loaded = false
-        @attribute_names = nil
-        direct_descendants.each do |descendant|
-          descendant.send(:reload_schema_from_cache)
+        def reload_schema_from_cache
+          @arel_table = nil
+          @column_names = nil
+          @symbol_column_to_string_name_hash = nil
+          @attribute_types = nil
+          @content_columns = nil
+          @default_attributes = nil
+          @column_defaults = nil
+          @inheritance_column = nil unless defined?(@explicit_inheritance_column) && @explicit_inheritance_column
+          @attributes_builder = nil
+          @columns = nil
+          @columns_hash = nil
+          @schema_loaded = false
+          @attribute_names = nil
+          @yaml_encoder = nil
+          direct_descendants.each do |descendant|
+            descendant.send(:reload_schema_from_cache)
+          end
         end
-      end
 
-      # Guesses the table name, but does not decorate it with prefix and suffix information.
-      def undecorated_table_name(class_name = base_class.name)
-        table_name = class_name.to_s.demodulize.underscore
-        pluralize_table_names ? table_name.pluralize : table_name
-      end
+        # Guesses the table name, but does not decorate it with prefix and suffix information.
+        def undecorated_table_name(class_name = base_class.name)
+          table_name = class_name.to_s.demodulize.underscore
+          pluralize_table_names ? table_name.pluralize : table_name
+        end
 
-      # Computes and returns a table name according to default conventions.
-      def compute_table_name
-        base = base_class
-        if self == base
-          # Nested classes are prefixed with singular parent table name.
-          if parent < Base && !parent.abstract_class?
-            contained = parent.table_name
-            contained = contained.singularize if parent.pluralize_table_names
-            contained += '_'
+        # Computes and returns a table name according to default conventions.
+        def compute_table_name
+          if base_class?
+            # Nested classes are prefixed with singular parent table name.
+            if module_parent < Base && !module_parent.abstract_class?
+              contained = module_parent.table_name
+              contained = contained.singularize if module_parent.pluralize_table_names
+              contained += "_"
+            end
+
+            "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
+          else
+            # STI subclasses always use their superclass' table.
+            base_class.table_name
           end
+        end
 
-          "#{full_table_name_prefix}#{contained}#{undecorated_table_name(name)}#{full_table_name_suffix}"
-        else
-          # STI subclasses always use their superclass' table.
-          base.table_name
+        def _convert_type_from_options(type)
+          if immutable_strings_by_default && type.respond_to?(:to_immutable_string)
+            type.to_immutable_string
+          else
+            type
+          end
         end
-      end
 
-      def warn_if_deprecated_type(column)
-        return if attributes_to_define_after_schema_loads.key?(column.name)
-        if column.respond_to?(:oid) && column.sql_type.start_with?("point")
+        def warn_if_deprecated_type(column)
+          return if attributes_to_define_after_schema_loads.key?(column.name)
+          return unless column.respond_to?(:oid)
+
           if column.array?
             array_arguments = ", array: true"
           else
             array_arguments = ""
           end
-          ActiveSupport::Deprecation.warn(<<-WARNING.strip_heredoc)
-            The behavior of the `:point` type will be changing in Rails 5.1 to
-            return a `Point` object, rather than an `Array`. If you'd like to
-            keep the old behavior, you can add this line to #{self.name}:
 
-              attribute :#{column.name}, :legacy_point#{array_arguments}
+          if column.sql_type.start_with?("interval")
+            precision_arguments = column.precision.presence && ", precision: #{column.precision}"
+            ActiveSupport::Deprecation.warn(<<~WARNING)
+              The behavior of the `:interval` type will be changing in Rails 6.2
+              to return an `ActiveSupport::Duration` object. If you'd like to keep
+              the old behavior, you can add this line to #{self.name} model:
+
+                attribute :#{column.name}, :string#{precision_arguments}#{array_arguments}
 
-            If you'd like the new behavior today, you can add this line:
+              If you'd like the new behavior today, you can add this line:
 
-              attribute :#{column.name}, :point#{array_arguments}
-          WARNING
+                attribute :#{column.name}, :interval#{precision_arguments}#{array_arguments}
+            WARNING
+          end
         end
-      end
     end
   end
 end