activerecord 6.1.0.rc1 → 6.1.2.1

data/lib/active_record/fixtures.rb

@@ -773,9 +773,12 @@ module ActiveRecord
 
     def find
       raise FixtureClassNotFound, "No class attached to find." unless model_class
-      model_class.unscoped do
+      object = model_class.unscoped do
         model_class.find(fixture[model_class.primary_key])
       end
+      # Fixtures can't be eagerly loaded
+      object.instance_variable_set(:@strict_loading, false)
+      object
     end
   end
 end

data/lib/active_record/gem_version.rb

@@ -9,8 +9,8 @@ module ActiveRecord
   module VERSION
     MAJOR = 6
     MINOR = 1
-    TINY  = 0
-    PRE   = "rc1"
+    TINY  = 2
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -69,6 +69,8 @@ module ActiveRecord
       attr_reader :scope_attributes
 
       def find_unique_index_for(unique_by)
+        return unique_by if !connection.supports_insert_conflict_target?
+
         name_or_columns = unique_by || model.primary_key
         match = Array(name_or_columns).map(&:to_s)
 

data/lib/active_record/internal_metadata.rb

@@ -43,11 +43,9 @@ module ActiveRecord
       def create_table
         return unless enabled?
 
-        unless table_exists?
-          key_options = connection.internal_string_options_for_primary_key
-
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :key, **key_options
+            t.string :key, **connection.internal_string_options_for_primary_key
             t.string :value
             t.timestamps
           end

data/lib/active_record/locking/optimistic.rb

@@ -89,7 +89,9 @@ module ActiveRecord
 
           begin
             locking_column = self.class.locking_column
-            previous_lock_value = attribute_before_type_cast(locking_column)
+            lock_attribute_was = @attributes[locking_column]
+            lock_value_for_database = _lock_value_for_database(locking_column)
+
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
 
@@ -98,7 +100,7 @@ module ActiveRecord
             affected_rows = self.class._update_record(
               attributes_with_values(attribute_names),
               @primary_key => id_in_database,
-              locking_column => @attributes[locking_column].original_value_for_database
+              locking_column => lock_value_for_database
             )
 
             if affected_rows != 1
@@ -109,7 +111,7 @@ module ActiveRecord
 
           # If something went wrong, revert the locking_column value.
           rescue Exception
-            self[locking_column] = previous_lock_value.to_i
+            @attributes[locking_column] = lock_attribute_was
             raise
           end
         end
@@ -121,7 +123,7 @@ module ActiveRecord
 
           affected_rows = self.class._delete_record(
             @primary_key => id_in_database,
-            locking_column => attribute_before_type_cast(locking_column)
+            locking_column => _lock_value_for_database(locking_column)
           )
 
           if affected_rows != 1
@@ -131,6 +133,14 @@ module ActiveRecord
           affected_rows
         end
 
+        def _lock_value_for_database(locking_column)
+          if will_save_change_to_attribute?(locking_column)
+            @attributes[locking_column].value_for_database
+          else
+            @attributes[locking_column].original_value_for_database
+          end
+        end
+
         module ClassMethods
           DEFAULT_LOCKING_COLUMN = "lock_version"
 

data/lib/active_record/log_subscriber.rb

@@ -22,9 +22,10 @@ module ActiveRecord
     def strict_loading_violation(event)
       debug do
         owner = event.payload[:owner]
-        association = event.payload[:association]
+        association = event.payload[:reflection].klass
+        name = event.payload[:reflection].name
 
-        color("Strict loading violation: #{association} lazily loaded on #{owner}.", RED)
+        color("Strict loading violation: #{owner} is marked for strict loading. The #{association} association named :#{name} cannot be lazily loaded.", RED)
       end
     end
 

data/lib/active_record/migration/compatibility.rb

@@ -56,7 +56,8 @@ module ActiveRecord
         end
 
         def add_reference(table_name, ref_name, **options)
-          ReferenceDefinition.new(ref_name, **options).add_to(update_table_definition(table_name, self))
+          ReferenceDefinition.new(ref_name, **options)
+            .add_to(connection.update_table_definition(table_name, self))
         end
         alias :add_belongs_to :add_reference
 

data/lib/active_record/model_schema.rb

@@ -297,6 +297,35 @@ 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)
         reload_schema_from_cache
         @ignored_columns = columns.map(&:to_s).freeze

data/lib/active_record/railtie.rb

@@ -31,7 +31,7 @@ module ActiveRecord
     config.active_record.maintain_test_schema = true
     config.active_record.has_many_inversing = false
 
-    config.active_record.queues = ActiveSupport::InheritableOptions.new(destroy: :active_record_destroy)
+    config.active_record.queues = ActiveSupport::InheritableOptions.new
 
     config.eager_load_namespaces << ActiveRecord
 
@@ -183,7 +183,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
                 end
               end
             rescue ActiveRecordError => error
-              # Regardless of wether there was already a connection or not, we rescue any database
+              # Regardless of whether there was already a connection or not, we rescue any database
               # error because it is critical that the application can boot even if the database
               # is unhealthy.
               warn "Failed to define attribute methods because of #{error.class}: #{error.message}"

data/lib/active_record/railties/console_sandbox.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-ActiveRecord::Base.connection.begin_transaction(joinable: false)
-
-at_exit do
-  ActiveRecord::Base.connection.rollback_transaction
+ActiveRecord::ConnectionAdapters::AbstractAdapter.set_callback(:checkout, :after) do
+  begin_transaction(joinable: false)
 end

data/lib/active_record/railties/databases.rake

@@ -361,17 +361,23 @@ db_namespace = namespace :db do
 
       # Skipped when no database
       ActiveRecord::Tasks::DatabaseTasks.migrate
+
       if ActiveRecord::Base.dump_schema_after_migration
         ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ActiveRecord::Base.schema_format)
       end
-
     rescue ActiveRecord::NoDatabaseError
-      ActiveRecord::Tasks::DatabaseTasks.create_current(db_config.env_name, db_config.name)
-      ActiveRecord::Tasks::DatabaseTasks.load_schema(
-        db_config,
-        ActiveRecord::Base.schema_format,
-        nil
-      )
+      config_name = db_config.name
+      ActiveRecord::Tasks::DatabaseTasks.create_current(db_config.env_name, config_name)
+
+      if File.exist?(ActiveRecord::Tasks::DatabaseTasks.dump_filename(config_name))
+        ActiveRecord::Tasks::DatabaseTasks.load_schema(
+          db_config,
+          ActiveRecord::Base.schema_format,
+          nil
+        )
+      else
+        ActiveRecord::Tasks::DatabaseTasks.migrate
+      end
 
       seed = true
     end
@@ -455,6 +461,14 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.load_schema_current(ActiveRecord::Base.schema_format, ENV["SCHEMA"])
     end
 
+    task load_if_ruby: ["db:create", :environment] do
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        Using `bin/rails db:schema:load_if_ruby` is deprecated and will be removed in Rails 6.2.
+        Configure the format using `config.active_record.schema_format = :ruby` to use `schema.rb` and run `bin/rails db:schema:load` instead.
+      MSG
+      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :ruby
+    end
+
     namespace :dump do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Creates a database schema file (either db/schema.rb or db/structure.sql, depending on `config.active_record.schema_format`) for #{name} database"
@@ -529,6 +543,14 @@ db_namespace = namespace :db do
       db_namespace["schema:load"].invoke
     end
 
+    task load_if_sql: ["db:create", :environment] do
+      ActiveSupport::Deprecation.warn(<<-MSG.squish)
+        Using `bin/rails db:structure:load_if_sql` is deprecated and will be removed in Rails 6.2.
+        Configure the format using `config.active_record.schema_format = :sql` to use `structure.sql` and run `bin/rails db:schema:load` instead.
+      MSG
+      db_namespace["schema:load"].invoke if ActiveRecord::Base.schema_format == :sql
+    end
+
     namespace :dump do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Dumps the #{name} database structure to db/structure.sql. Specify another file with SCHEMA=db/my_structure.sql"

data/lib/active_record/reflection.rb

@@ -162,7 +162,7 @@ module ActiveRecord
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
       # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
       def class_name
-        @class_name ||= -(options[:class_name]&.to_s || derive_class_name)
+        @class_name ||= -(options[:class_name] || derive_class_name).to_s
       end
 
       # Returns a list of scopes that should be applied for this Reflection
@@ -623,6 +623,7 @@ module ActiveRecord
         # with the current reflection's klass name.
         def valid_inverse_reflection?(reflection)
           reflection &&
+            foreign_key == reflection.foreign_key &&
             klass <= reflection.active_record &&
             can_find_inverse_of_automatically?(reflection)
         end

data/lib/active_record/relation/predicate_builder.rb

@@ -32,9 +32,9 @@ module ActiveRecord
     def self.references(attributes)
       attributes.each_with_object([]) do |(key, value), result|
         if value.is_a?(Hash)
-          result << key
+          result << Arel.sql(key)
         elsif key.include?(".")
-          result << key.split(".").first
+          result << Arel.sql(key.split(".").first)
         end
       end
     end
@@ -59,7 +59,7 @@ module ActiveRecord
     end
 
     def build(attribute, value, operator = nil)
-      value = value.id if value.is_a?(Base)
+      value = value.id if value.respond_to?(:id)
       if operator ||= table.type(attribute.name).force_equality?(value) && :eq
         bind = build_bind_attribute(attribute.name, value)
         attribute.public_send(operator, bind)
@@ -93,14 +93,11 @@ module ActiveRecord
             # PriceEstimate.where(estimate_of: treasure)
             associated_table = table.associated_table(key)
             if associated_table.polymorphic_association?
-              case value.is_a?(Array) ? value.first : value
-              when Base, Relation
-                value = [value] unless value.is_a?(Array)
-                klass = PolymorphicArrayValue
-              end
+              value = [value] unless value.is_a?(Array)
+              klass = PolymorphicArrayValue
             elsif associated_table.through_association?
               next associated_table.predicate_builder.expand_from_hash(
-                associated_table.join_foreign_key => value
+                associated_table.primary_key => value
               )
             end
 

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

@@ -9,7 +9,7 @@ module ActiveRecord
       end
 
       def queries
-        [associated_table.join_foreign_key => ids]
+        [ associated_table.join_foreign_key => ids ]
       end
 
       private
@@ -31,9 +31,8 @@ module ActiveRecord
         end
 
         def convert_to_id(value)
-          case value
-          when Base
-            value._read_attribute(primary_key)
+          if value.respond_to?(primary_key)
+            value.public_send(primary_key)
           else
             value
           end

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

@@ -9,11 +9,13 @@ module ActiveRecord
       end
 
       def queries
+        return [ associated_table.join_foreign_key => values ] if values.empty?
+
         type_to_ids_mapping.map do |type, ids|
-          {
-            associated_table.join_foreign_type => type,
-            associated_table.join_foreign_key => ids
-          }
+          query = {}
+          query[associated_table.join_foreign_type] = type if type
+          query[associated_table.join_foreign_key] = ids
+          query
         end
       end
 
@@ -23,7 +25,7 @@ module ActiveRecord
         def type_to_ids_mapping
           default_hash = Hash.new { |hsh, key| hsh[key] = [] }
           values.each_with_object(default_hash) do |value, hash|
-            hash[klass(value).polymorphic_name] << convert_to_id(value)
+            hash[klass(value)&.polymorphic_name] << convert_to_id(value)
           end
         end
 
@@ -46,6 +48,8 @@ module ActiveRecord
             value._read_attribute(primary_key(value))
           when Relation
             value.select(primary_key(value))
+          else
+            value
           end
         end
     end

data/lib/active_record/relation/query_methods.rb

@@ -1081,12 +1081,15 @@ module ActiveRecord
         when String, Array
           parts = [klass.sanitize_sql(rest.empty? ? opts : [opts, *rest])]
         when Hash
-          opts = opts.stringify_keys
+          opts = opts.transform_keys do |key|
+            key = key.to_s
+            klass.attribute_aliases[key] || key
+          end
           references = PredicateBuilder.references(opts)
           self.references_values |= references unless references.empty?
 
           parts = predicate_builder.build_from_hash(opts) do |table_name|
-            lookup_reflection_from_join_dependencies(table_name)
+            lookup_table_klass_from_join_dependencies(table_name)
           end
         when Arel::Nodes::Node
           parts = [opts]
@@ -1099,9 +1102,9 @@ module ActiveRecord
       alias :build_having_clause :build_where_clause
 
     private
-      def lookup_reflection_from_join_dependencies(table_name)
+      def lookup_table_klass_from_join_dependencies(table_name)
         each_join_dependencies do |join|
-          return join.reflection if table_name == join.table_name
+          return join.base_klass if table_name == join.table_name
         end
         nil
       end
@@ -1312,7 +1315,7 @@ module ActiveRecord
         elsif field.match?(/\A\w+\.\w+\z/)
           table, column = field.split(".")
           predicate_builder.resolve_arel_attribute(table, column) do
-            lookup_reflection_from_join_dependencies(table)
+            lookup_table_klass_from_join_dependencies(table)
           end
         else
           yield field
@@ -1505,7 +1508,7 @@ module ActiveRecord
             v1 = v1.uniq
             v2 = v2.uniq
           end
-          v1 == v2 || (!v1 || v1.empty?) && (!v2 || v2.empty?)
+          v1 == v2
         end
       end
   end

data/lib/active_record/relation/spawn_methods.rb

@@ -69,8 +69,8 @@ module ActiveRecord
 
     private
       def relation_with(values)
-        result = Relation.create(klass, values: values)
-        result.extend(*extending_values) if extending_values.any?
+        result = spawn
+        result.instance_variable_set(:@values, values)
         result
       end
   end

data/lib/active_record/schema_migration.rb

@@ -23,11 +23,9 @@ module ActiveRecord
       end
 
       def create_table
-        unless table_exists?
-          version_options = connection.internal_string_options_for_primary_key
-
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :version, **version_options
+            t.string :version, **connection.internal_string_options_for_primary_key
           end
         end
       end

data/lib/active_record/signed_id.rb

@@ -20,7 +20,7 @@ module ActiveRecord
       # a certain time period.
       #
       # You set the time period that the signed id is valid for during generation, using the instance method
-      # +signed_id(expires_in: 15.minutes)+. If the time has elapsed before a signed find is attempted,
+      # <tt>signed_id(expires_in: 15.minutes)</tt>. If the time has elapsed before a signed find is attempted,
       # the signed id will no longer be valid, and nil is returned.
       #
       # It's possible to further restrict the use of a signed id with a purpose. This helps when you have a