activerecord 7.0.0.rc1 → 7.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1a1968982fd2d7c0361ac7cfa9241a02c4ff558cc8fba93545800194274ac90
-  data.tar.gz: e19875a1df942ea1488aff91d0026e8584945504b14f9021660a1b55831f2ad2
+  metadata.gz: e0de65b8a004bb74ee8951a2d34e5630f67568091f4c72bd99e28aaf8dd73097
+  data.tar.gz: 56d07fdf1ec276b9b88c7a13e79cfe4cfb3f3768dcbd1b5bf0f828bd2ba657d6
 SHA512:
-  metadata.gz: 17e093b64278febf6fa7db08a4184650581efeabdc2b32c652c2818951fa9608cd2bd804ba51304cbace26ffb2d83873ea416f29d600017161b607968e4fbe7e
-  data.tar.gz: cffe209fcb1de322ef8089a95b24940db52ac4cc5086c6fc7a749646a2e14f83a15384785a2bb390c149b770a17e9597789d12ceffb38e925e6067772d8a0556
+  metadata.gz: 2bf02198176f838235234fefd0658de10a37c51d704becaeccd1f8040ed4d79360a5128411c01af7226ca0c5806c5ed892c1fc55fc27cca55f48f5dc181d5dd5
+  data.tar.gz: e781dd6be129520aaeab76b1fea5bf98ce25793c623c2cde18cfd293fd2222c28e3d16ad4f8978688a74eaf683c2a6283358d7f815b8a924a0cc66f16c051c1e

data/CHANGELOG.md

@@ -1,3 +1,131 @@
+## Rails 7.0.1 (January 06, 2022) ##
+
+*   Change `QueryMethods#in_order_of` to drop records not listed in values.
+
+    `in_order_of` now filters down to the values provided, to match the behavior of the `Enumerable` version.
+
+    *Kevin Newton*
+
+*   Allow named expression indexes to be revertible.
+
+    Previously, the following code would raise an error in a reversible migration executed while rolling back, due to the index name not being used in the index removal.
+
+    ```ruby
+    add_index(:settings, "(data->'property')", using: :gin, name: :index_settings_data_property)
+    ```
+
+    Fixes #43331.
+
+    *Oliver Günther*
+
+*   Better error messages when association name is invalid in the argument of `ActiveRecord::QueryMethods::WhereChain#missing`.
+
+    *ykpythemind*
+
+*   Fix ordered migrations for single db in multi db environment.
+
+    *Himanshu*
+
+*   Extract `on update CURRENT_TIMESTAMP` for mysql2 adapter.
+
+    *Kazuhiro Masuda*
+
+*   Fix incorrect argument in PostgreSQL structure dump tasks.
+
+    Updating the `--no-comment` argument added in Rails 7 to the correct `--no-comments` argument.
+
+    *Alex Dent*
+
+*   Fix schema dumping column default SQL values for sqlite3.
+
+    *fatkodima*
+
+*   Correctly parse complex check constraint expressions for PostgreSQL.
+
+    *fatkodima*
+
+*   Fix `timestamptz` attributes on PostgreSQL handle blank inputs.
+
+    *Alex Ghiculescu*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when migration version is 6.0.
+
+    Reference/belongs_to in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
+
+    *Marcelo Lauxen*
+
+*   Fix joining through a polymorphic association.
+
+    *Alexandre Ruban*
+
+*   Fix `QueryMethods#in_order_of` to handle empty order list.
+
+    ```ruby
+    Post.in_order_of(:id, []).to_a
+    ```
+
+    Also more explicitly set the column as secondary order, so that any other
+    value is still ordered.
+
+    *Jean Boussier*
+
+*   Fix `rails dbconsole` for 3-tier config.
+
+    *Eileen M. Uchitelle*
+
+*   Fix quoting of column aliases generated by calculation methods.
+
+    Since the alias is derived from the table name, we can't assume the result
+    is a valid identifier.
+
+    ```ruby
+    class Test < ActiveRecord::Base
+      self.table_name = '1abc'
+    end
+    Test.group(:id).count
+    # syntax error at or near "1" (ActiveRecord::StatementInvalid)
+    # LINE 1: SELECT COUNT(*) AS count_all, "1abc"."id" AS 1abc_id FROM "1...
+    ```
+
+    *Jean Boussier*
+
+
+## Rails 7.0.0 (December 15, 2021) ##
+
+*   Better handle SQL queries with invalid encoding.
+
+    ```ruby
+    Post.create(name: "broken \xC8 UTF-8")
+    ```
+
+    Would cause all adapters to fail in a non controlled way in the code
+    responsible to detect write queries.
+
+    The query is now properly passed to the database connection, which might or might
+    not be able to handle it, but will either succeed or failed in a more correct way.
+
+    *Jean Boussier*
+
+*   Move database and shard selection config options to a generator.
+
+    Rather than generating the config options in `production.rb` when applications are created, applications can now run a generator to create an initializer and uncomment / update options as needed. All multi-db configuration can be implemented in this initializer.
+
+    *Eileen M. Uchitelle*
+
+
+## Rails 7.0.0.rc3 (December 14, 2021) ##
+
+*   No changes.
+
+
+## Rails 7.0.0.rc2 (December 14, 2021) ##
+
+*   No changes.
+
+
+## Rails 7.0.0.rc1 (December 06, 2021) ##
+
 *   Remove deprecated `ActiveRecord::DatabaseConfigurations::DatabaseConfig#spec_name`.
 
     *Rafael Mendonça França*
@@ -305,7 +433,6 @@
 
     Applications may now set their the filename or path of the schema / structure dump file in their database configuration.
 
-
     ```yaml
     production:
       primary:
@@ -392,6 +519,8 @@
     `#with_lock` now accepts transaction options like `requires_new:`,
     `isolation:`, and `joinable:`
 
+    *John Mileham*
+
 *   Adds support for deferrable foreign key constraints in PostgreSQL.
 
     By default, foreign key constraints in PostgreSQL are checked after each statement. This works for most use cases,
@@ -468,7 +597,7 @@
 
     *Alex Ghiculescu*
 
-* Avoid COMMENT statements in PostgreSQL structure dumps
+*   Avoid COMMENT statements in PostgreSQL structure dumps
 
     COMMENT statements are now omitted from the output of `db:structure:dump` when using PostgreSQL >= 11.
     This allows loading the dump without a pgsql superuser account.
@@ -521,7 +650,7 @@
 
     *Sam Bostock*
 
-* Add ssl support for postgresql database tasks
+*   Add ssl support for postgresql database tasks
 
     Add `PGSSLMODE`, `PGSSLCERT`, `PGSSLKEY` and `PGSSLROOTCERT` to pg_env from database config
     when running postgresql database tasks.

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2021 David Heinemeier Hansson
+Copyright (c) 2004-2022 David Heinemeier Hansson
 
 Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 

data/lib/active_record/associations/join_dependency.rb

@@ -3,8 +3,12 @@
 module ActiveRecord
   module Associations
     class JoinDependency # :nodoc:
-      autoload :JoinBase,        "active_record/associations/join_dependency/join_base"
-      autoload :JoinAssociation, "active_record/associations/join_dependency/join_association"
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :JoinBase
+        autoload :JoinAssociation
+      end
 
       class Aliases # :nodoc:
         def initialize(tables)

data/lib/active_record/associations.rb

@@ -594,19 +594,27 @@ module ActiveRecord
       # you can also define callbacks that get triggered when you add an object to or remove an
       # object from an association collection.
       #
-      #   class Project
-      #     has_and_belongs_to_many :developers, after_add: :evaluate_velocity
+      #   class Firm < ActiveRecord::Base
+      #     has_many :clients,
+      #              dependent: :destroy,
+      #              after_add: :congratulate_client,
+      #              after_remove: :log_after_remove
       #
-      #     def evaluate_velocity(developer)
-      #       ...
+      #     def congratulate_client(record)
+      #       # ...
+      #     end
+      #
+      #     def log_after_remove(record)
+      #       # ...
       #     end
-      #   end
       #
       # It's possible to stack callbacks by passing them as an array. Example:
       #
-      #   class Project
-      #     has_and_belongs_to_many :developers,
-      #                             after_add: [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
+      #   class Firm < ActiveRecord::Base
+      #     has_many :clients,
+      #              dependent: :destroy,
+      #              after_add: [:congratulate_client, -> (firm, record) { firm.log << "after_adding#{record.id}" }],
+      #              after_remove: :log_after_remove
       #   end
       #
       # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
@@ -617,6 +625,18 @@ module ActiveRecord
       # Similarly, if any of the +before_remove+ callbacks throw an exception, the object
       # will not be removed from the collection.
       #
+      # Note: To trigger remove callbacks, you must use +destroy+ / +destroy_all+ methods. For example:
+      #
+      #   * <tt>firm.clients.destroy(client)</tt>
+      #   * <tt>firm.clients.destroy(*clients)</tt>
+      #   * <tt>firm.clients.destroy_all</tt>
+      #
+      # +delete+ / +delete_all+ methods like the following do *not* trigger remove callbacks:
+      #
+      #   * <tt>firm.clients.delete(client)</tt>
+      #   * <tt>firm.clients.delete(*clients)</tt>
+      #   * <tt>firm.clients.delete_all</tt>
+      #
       # == Association extensions
       #
       # The proxy objects that control the access to associations can be extended through anonymous

data/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1438,7 +1438,7 @@ module ActiveRecord
 
           checks = []
 
-          if !options.key?(:name) && column_name.is_a?(String) && /\W/.match?(column_name)
+          if !options.key?(:name) && expression_column_name?(column_name)
             options[:name] = index_name(table_name, column_name)
             column_names = []
           else
@@ -1447,7 +1447,7 @@ module ActiveRecord
 
           checks << lambda { |i| i.name == options[:name].to_s } if options.key?(:name)
 
-          if column_names.present?
+          if column_names.present? && !(options.key?(:name) && expression_column_name?(column_names))
             checks << lambda { |i| index_name(table_name, i.columns) == index_name(table_name, column_names) }
           end
 
@@ -1515,7 +1515,7 @@ module ActiveRecord
         end
 
         def index_column_names(column_names)
-          if column_names.is_a?(String) && /\W/.match?(column_names)
+          if expression_column_name?(column_names)
             column_names
           else
             Array(column_names)
@@ -1523,13 +1523,18 @@ module ActiveRecord
         end
 
         def index_name_options(column_names)
-          if column_names.is_a?(String) && /\W/.match?(column_names)
+          if expression_column_name?(column_names)
             column_names = column_names.scan(/\w+/).join("_")
           end
 
           { column: column_names }
         end
 
+        # Try to identify whether the given column name is an expression
+        def expression_column_name?(column_name)
+          column_name.is_a?(String) && /\W/.match?(column_name)
+        end
+
         def strip_table_name_prefix_and_suffix(table_name)
           prefix = Base.table_name_prefix
           suffix = Base.table_name_suffix

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -197,7 +197,7 @@ module ActiveRecord
 
       # Executes the SQL statement in the context of this connection.
       def execute(sql, name = nil, async: false)
-        raw_execute(sql, name, async)
+        raw_execute(sql, name, async: async)
       end
 
       # Mysql2Adapter doesn't have to free a result after using it, but we use this method

data/lib/active_record/connection_adapters/mysql/database_statements.rb

@@ -26,6 +26,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         def explain(arel, binds = [])

data/lib/active_record/connection_adapters/mysql/schema_statements.rb

@@ -163,6 +163,7 @@ module ActiveRecord
             default, default_function = field[:Default], nil
 
             if type_metadata.type == :datetime && /\ACURRENT_TIMESTAMP(?:\([0-6]?\))?\z/i.match?(default)
+              default = "#{default} ON UPDATE #{default}" if /on update CURRENT_TIMESTAMP/i.match?(field[:Extra])
               default, default_function = nil, default
             elsif type_metadata.extra == "DEFAULT_GENERATED"
               default = +"(#{default})" unless default.start_with?("(")

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -28,6 +28,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Executes an SQL statement, returning a PG::Result object on success

data/lib/active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone.rb

@@ -10,6 +10,8 @@ module ActiveRecord
           end
 
           def cast_value(value)
+            return if value.blank?
+
             time = super
             return time if time.is_a?(ActiveSupport::TimeWithZone)
 

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -525,7 +525,7 @@ module ActiveRecord
           scope = quoted_scope(table_name)
 
           check_info = exec_query(<<-SQL, "SCHEMA")
-            SELECT conname, pg_get_constraintdef(c.oid) AS constraintdef, c.convalidated AS valid
+            SELECT conname, pg_get_constraintdef(c.oid, true) AS constraintdef, c.convalidated AS valid
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid
             WHERE c.contype = 'c'
@@ -537,7 +537,7 @@ module ActiveRecord
               name: row["conname"],
               validate: row["valid"]
             }
-            expression = row["constraintdef"][/CHECK \({2}(.+)\){2}/, 1]
+            expression = row["constraintdef"][/CHECK \((.+)\)/m, 1]
 
             CheckConstraintDefinition.new(table_name, expression, options)
           end
@@ -569,7 +569,7 @@ module ActiveRecord
               else raise ArgumentError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead."
               end
             when "enum"
-              raise ArgumentError "enum_type is required for enums" if enum_type.nil?
+              raise ArgumentError, "enum_type is required for enums" if enum_type.nil?
 
               enum_type
             else

data/lib/active_record/connection_adapters/sqlite3/database_statements.rb

@@ -11,6 +11,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         def explain(arel, binds = [])

data/lib/active_record/connection_adapters/sqlite3/quoting.rb

@@ -45,6 +45,19 @@ module ActiveRecord
           0
         end
 
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value = value.call
+            if value.match?(/\A\w+\(.*\)\z/)
+              "(#{value})"
+            else
+              value
+            end
+          else
+            super
+          end
+        end
+
         def type_cast(value) # :nodoc:
           case value
           when BigDecimal

data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb

@@ -127,20 +127,20 @@ module ActiveRecord
           end
 
           def new_column_from_field(table_name, field)
-            default = \
-              case field["dflt_value"]
-              when /^null$/i
-                nil
-              when /^'(.*)'$/m
-                $1.gsub("''", "'")
-              when /^"(.*)"$/m
-                $1.gsub('""', '"')
-              else
-                field["dflt_value"]
-              end
+            default = field["dflt_value"]
 
             type_metadata = fetch_type_metadata(field["type"])
-            Column.new(field["name"], default, type_metadata, field["notnull"].to_i == 0, collation: field["collation"])
+            default_value = extract_value_from_default(default)
+            default_function = extract_default_function(default_value, default)
+
+            Column.new(
+              field["name"],
+              default_value,
+              type_metadata,
+              field["notnull"].to_i == 0,
+              default_function,
+              collation: field["collation"]
+            )
           end
 
           def data_source_sql(name = nil, type: nil)

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -389,6 +389,34 @@ module ActiveRecord
         end
         alias column_definitions table_structure
 
+        def extract_value_from_default(default)
+          case default
+          when /^null$/i
+            nil
+          # Quoted types
+          when /^'(.*)'$/m
+            $1.gsub("''", "'")
+          # Quoted types
+          when /^"(.*)"$/m
+            $1.gsub('""', '"')
+          # Numeric types
+          when /\A-?\d+(\.\d*)?\z/
+            $&
+          else
+            # Anything else is blank or some function
+            # and we can't know the value of that, so return nil.
+            nil
+          end
+        end
+
+        def extract_default_function(default_value, default)
+          default if has_default_function?(default_value, default)
+        end
+
+        def has_default_function?(default_value, default)
+          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+        end
+
         # See: https://www.sqlite.org/lang_altertable.html
         # SQLite has an additional restriction on the ALTER TABLE statement
         def invalid_alter_table_type?(type, options)

data/lib/active_record/encryption/encryptable_record.rb

@@ -37,7 +37,7 @@ module ActiveRecord
         #   in preserving it.
         # * <tt>:ignore_case</tt> - When true, it behaves like +:downcase+ but, it also preserves the original case in a specially
         #   designated column +original_<name>+. When reading the encrypted content, the version with the original case is
-        #   server. But you can still execute queries that will ignore the case. This option can only be used when +:deterministic+
+        #   served. But you can still execute queries that will ignore the case. This option can only be used when +:deterministic+
         #   is true.
         # * <tt>:context_properties</tt> - Additional properties that will override +Context+ settings when this attribute is
         #   encrypted and decrypted. E.g: +encryptor:+, +cipher:+, +message_serializer:+, etc.

data/lib/active_record/encryption/extended_deterministic_queries.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
-# Automatically expand encrypted arguments to support querying both encrypted and unencrypted data
-#
-# Active Record Encryption supports querying the db using deterministic attributes. For example:
-#
-#   Contact.find_by(email_address: "jorge@hey.com")
-#
-# The value "jorge@hey.com" will get encrypted automatically to perform the query. But there is
-# a problem while the data is being encrypted. This won't work. During that time, you need these
-# queries to be:
-#
-#   Contact.find_by(email_address: [ "jorge@hey.com", "<encrypted jorge@hey.com>" ])
-#
-# This patches ActiveRecord to support this automatically. It addresses both:
-#
-# * ActiveRecord::Base: Used in +Contact.find_by_email_address(...)+
-# * ActiveRecord::Relation: Used in +Contact.internal.find_by_email_address(...)+
-#
-# +ActiveRecord::Base+ relies on +ActiveRecord::Relation+ (+ActiveRecord::QueryMethods+) but it does
-# some prepared statements caching. That's why we need to intercept +ActiveRecord::Base+ as soon
-# as it's invoked (so that the proper prepared statement is cached).
-#
-# When modifying this file run performance tests in +test/performance/extended_deterministic_queries_performance_test.rb+ to
-#   make sure performance overhead is acceptable.
-#
-# We will extend this to support previous "encryption context" versions in future iterations
-#
-# @TODO Experimental. Support for every kind of query is pending
-# @TODO It should not patch anything if not needed (no previous schemes or no support for previous encryption schemes)
 module ActiveRecord
   module Encryption
+    # Automatically expand encrypted arguments to support querying both encrypted and unencrypted data
+    #
+    # Active Record Encryption supports querying the db using deterministic attributes. For example:
+    #
+    #   Contact.find_by(email_address: "jorge@hey.com")
+    #
+    # The value "jorge@hey.com" will get encrypted automatically to perform the query. But there is
+    # a problem while the data is being encrypted. This won't work. During that time, you need these
+    # queries to be:
+    #
+    #   Contact.find_by(email_address: [ "jorge@hey.com", "<encrypted jorge@hey.com>" ])
+    #
+    # This patches ActiveRecord to support this automatically. It addresses both:
+    #
+    # * ActiveRecord::Base: Used in +Contact.find_by_email_address(...)+
+    # * ActiveRecord::Relation: Used in +Contact.internal.find_by_email_address(...)+
+    #
+    # +ActiveRecord::Base+ relies on +ActiveRecord::Relation+ (+ActiveRecord::QueryMethods+) but it does
+    # some prepared statements caching. That's why we need to intercept +ActiveRecord::Base+ as soon
+    # as it's invoked (so that the proper prepared statement is cached).
+    #
+    # When modifying this file run performance tests in +test/performance/extended_deterministic_queries_performance_test.rb+ to
+    #   make sure performance overhead is acceptable.
+    #
+    # We will extend this to support previous "encryption context" versions in future iterations
+    #
+    # @TODO Experimental. Support for every kind of query is pending
+    # @TODO It should not patch anything if not needed (no previous schemes or no support for previous encryption schemes)
     module ExtendedDeterministicQueries
       def self.install_support
         ActiveRecord::Relation.prepend(RelationQueries)

data/lib/active_record/gem_version.rb

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

data/lib/active_record/migration/compatibility.rb

@@ -92,6 +92,22 @@ module ActiveRecord
           end
         end
 
+        module SQLite3
+          module TableDefinition
+            def references(*args, **options)
+              args.each do |ref_name|
+                ReferenceDefinition.new(ref_name, type: :integer, **options).add_to(self)
+              end
+            end
+            alias :belongs_to :references
+
+            def column(name, type, index: nil, **options)
+              options[:precision] ||= nil
+              super
+            end
+          end
+        end
+
         module TableDefinition
           def references(*args, **options)
             args.each do |ref_name|
@@ -131,8 +147,13 @@ module ActiveRecord
         end
 
         def add_reference(table_name, ref_name, **options)
-          ReferenceDefinition.new(ref_name, **options)
-            .add_to(connection.update_table_definition(table_name, self))
+          if connection.adapter_name == "SQLite"
+            reference_definition = ReferenceDefinition.new(ref_name, type: :integer, **options)
+          else
+            reference_definition = ReferenceDefinition.new(ref_name, **options)
+          end
+
+          reference_definition.add_to(connection.update_table_definition(table_name, self))
         end
         alias :add_belongs_to :add_reference
 
@@ -140,6 +161,7 @@ module ActiveRecord
           def compatible_table_definition(t)
             class << t
               prepend TableDefinition
+              prepend SQLite3::TableDefinition
             end
             t
           end

data/lib/active_record/migration.rb

@@ -1080,7 +1080,7 @@ module ActiveRecord
     # 0 then an empty array will be returned and no migrations
     # will be run.
     #
-    # If the +current_version+ in the schema is less than
+    # If the +current_version+ in the schema is greater than
     # the +target_version+, then +down+ will be run.
     #
     # If none of the conditions are met, +up+ will be run with

data/lib/active_record/reflection.rb

@@ -1031,7 +1031,7 @@ module ActiveRecord
       end
 
       def join_scopes(table, predicate_builder, klass = self.klass, record = nil) # :nodoc:
-        scopes = @previous_reflection.join_scopes(table, predicate_builder, record) + super
+        scopes = @previous_reflection.join_scopes(table, predicate_builder, klass, record) + super
         scopes << build_scope(table, predicate_builder, klass).instance_exec(record, &source_type_scope)
       end
 

data/lib/active_record/relation/calculations.rb

@@ -155,7 +155,7 @@ module ActiveRecord
     end
 
     # Use #pluck as a shortcut to select one or more attributes without
-    # loading a bunch of records just to grab the attributes you want.
+    # loading an entire record object per row.
     #
     #   Person.pluck(:name)
     #
@@ -345,12 +345,13 @@ module ActiveRecord
         column = aggregate_column(column_name)
         column_alias = column_alias_for("#{operation} #{column_name.to_s.downcase}")
         select_value = operation_over_aggregate_column(column, operation, distinct)
-        select_value.as(column_alias)
+        select_value.as(connection.quote_column_name(column_alias))
 
         select_values = [select_value]
         select_values += self.select_values unless having_clause.empty?
 
         select_values.concat group_columns.map { |aliaz, field|
+          aliaz = connection.quote_column_name(aliaz)
           if field.respond_to?(:as)
             field.as(aliaz)
           else

data/lib/active_record/relation/query_methods.rb

@@ -97,6 +97,9 @@ module ActiveRecord
       def missing(*associations)
         associations.each do |association|
           reflection = @scope.klass._reflect_on_association(association)
+          unless reflection
+            raise ArgumentError.new("An association named `:#{association}` does not exist on the model `#{@scope.name}`.")
+          end
           @scope.left_outer_joins!(association)
           @scope.where!(reflection.table_name => { reflection.association_primary_key => nil })
         end
@@ -424,18 +427,23 @@ module ActiveRecord
     # adapter this will either use a CASE statement or a built-in function.
     #
     #   User.in_order_of(:id, [1, 5, 3])
-    #   # SELECT "users".* FROM "users" ORDER BY FIELD("users"."id", 1, 5, 3)
+    #   # SELECT "users".* FROM "users"
+    #   #   ORDER BY FIELD("users"."id", 1, 5, 3)
+    #   #   WHERE "users"."id" IN (1, 5, 3)
     #
     def in_order_of(column, values)
       klass.disallow_raw_sql!([column], permit: connection.column_name_with_order_matcher)
+      return spawn.none! if values.empty?
 
       references = column_references([column])
       self.references_values |= references unless references.empty?
 
       values = values.map { |value| type_caster.type_cast_for_database(column, value) }
-      column = order_column(column.to_s) if column.is_a?(Symbol)
+      arel_column = column.is_a?(Symbol) ? order_column(column.to_s) : column
 
-      spawn.order!(connection.field_ordered_value(column, values))
+      spawn
+        .order!(connection.field_ordered_value(arel_column, values))
+        .where!(arel_column.in(values))
     end
 
     # Replaces any existing order defined on the relation with the specified order.

data/lib/active_record/relation.rb

@@ -33,7 +33,6 @@ module ActiveRecord
       @delegate_to_klass = false
       @future_result = nil
       @records = nil
-      @limited_count = nil
     end
 
     def initialize_copy(other)
@@ -647,6 +646,21 @@ module ActiveRecord
     # Schedule the query to be performed from a background thread pool.
     #
     #   Post.where(published: true).load_async # => #<ActiveRecord::Relation>
+    #
+    # When the +Relation+ is iterated, if the background query wasn't executed yet,
+    # it will be performed by the foreground thread.
+    #
+    # Note that {config.active_record.async_query_executor}[https://guides.rubyonrails.org/configuring.html#config-active-record-async-query-executor] must be configured
+    # for queries to actually be executed concurrently. Otherwise it defaults to
+    # executing them in the foreground.
+    #
+    # +load_async+ will also fallback to executing in the foreground in the test environment when transactional
+    # fixtures are enabled.
+    #
+    # If the query was actually executed in the background, the Active Record logs will show
+    # it by prefixing the log line with <tt>ASYNC</tt>:
+    #
+    #   ASYNC Post Load (0.0ms) (db time 2ms)  SELECT "posts".* FROM "posts" LIMIT 100
     def load_async
       return load if !connection.async_enabled?
 
@@ -699,7 +713,6 @@ module ActiveRecord
       @offsets = @take = nil
       @cache_keys = nil
       @records = nil
-      @limited_count = nil
       self
     end
 
@@ -974,7 +987,7 @@ module ActiveRecord
       end
 
       def limited_count
-        @limited_count ||= limit_value ? count : limit(2).count
+        limit_value ? count : limit(2).count
       end
   end
 end

data/lib/active_record/schema_migration.rb

@@ -41,6 +41,10 @@ module ActiveRecord
       def all_versions
         order(:version).pluck(:version)
       end
+
+      def table_exists?
+        connection.data_source_exists?(table_name)
+      end
     end
 
     def version

data/lib/active_record/tasks/database_tasks.rb

@@ -257,8 +257,12 @@ module ActiveRecord
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
-        Base.connection.migration_context.migrate(target_version || version) do |migration|
-          scope.blank? || scope == migration.scope
+        Base.connection.migration_context.migrate(target_version) do |migration|
+          if version.blank?
+            scope.blank? || scope == migration.scope
+          else
+            migration.version == version
+          end
         end.tap do |migrations_ran|
           Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -58,7 +58,7 @@ module ActiveRecord
           end
 
         args = ["--schema-only", "--no-privileges", "--no-owner"]
-        args << "--no-comment" if connection.database_version >= 110_000
+        args << "--no-comments" if connection.database_version >= 110_000
         args.concat(["--file", filename])
 
         args.concat(Array(extra_flags)) if extra_flags

data/lib/active_record.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #--
-# Copyright (c) 2004-2021 David Heinemeier Hansson
+# Copyright (c) 2004-2022 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/rails/generators/active_record/multi_db/multi_db_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ActiveRecord
+  module Generators # :nodoc:
+    class MultiDbGenerator < ::Rails::Generators::Base # :nodoc:
+      source_root File.expand_path("templates", __dir__)
+
+      def create_multi_db
+        filename = "multi_db.rb"
+        template filename, "config/initializers/#{filename}"
+      end
+    end
+  end
+end

data/lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt

@@ -0,0 +1,44 @@
+# Multi-db Configuration
+#
+# This file is used for configuration settings related to multiple databases.
+#
+# Enable Database Selector
+#
+# Inserts middleware to perform automatic connection switching.
+# The `database_selector` hash is used to pass options to the DatabaseSelector
+# middleware. The `delay` is used to determine how long to wait after a write
+# to send a subsequent read to the primary.
+#
+# The `database_resolver` class is used by the middleware to determine which
+# database is appropriate to use based on the time delay.
+#
+# The `database_resolver_context` class is used by the middleware to set
+# timestamps for the last write to the primary. The resolver uses the context
+# class timestamps to determine how long to wait before reading from the
+# replica.
+#
+# By default Rails will store a last write timestamp in the session. The
+# DatabaseSelector middleware is designed as such you can define your own
+# strategy for connection switching and pass that into the middleware through
+# these configuration options.
+#
+# Rails.application.configure do
+#   config.active_record.database_selector = { delay: 2.seconds }
+#   config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+#   config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+# end
+#
+# Enable Shard Selector
+#
+# Inserts middleware to perform automatic shard swapping. The `shard_selector` hash
+# can be used to pass options to the `ShardSelector` middleware. The `lock` option is
+# used to determine whether shard swapping should be prohibited for the request.
+#
+# The `shard_resolver` option is used by the middleware to determine which shard
+# to switch to. The application must provide a mechanism for finding the shard name
+# in a proc. See guides for an example.
+#
+# Rails.application.configure do
+#   config.active_record.shard_selector = { lock: true }
+#   config.active_record.shard_resolver = ->(request) { Tenant.find_by!(host: request.host).shard }
+# end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 7.0.0.rc1
+  version: 7.0.1
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-06 00:00:00.000000000 Z
+date: 2022-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.0.rc1
+        version: 7.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.0.rc1
+        version: 7.0.1
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.0.rc1
+        version: 7.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.0.0.rc1
+        version: 7.0.1
 description: Databases on Rails. Build a persistent domain model by mapping database
   tables to Ruby classes. Strong conventions for associations, validations, aggregations,
   migrations, and testing come baked-in.
@@ -427,15 +427,17 @@ files:
 - lib/rails/generators/active_record/model/templates/abstract_base_class.rb.tt
 - lib/rails/generators/active_record/model/templates/model.rb.tt
 - lib/rails/generators/active_record/model/templates/module.rb.tt
+- lib/rails/generators/active_record/multi_db/multi_db_generator.rb
+- lib/rails/generators/active_record/multi_db/templates/multi_db.rb.tt
 homepage: https://rubyonrails.org
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails/rails/issues
-  changelog_uri: https://github.com/rails/rails/blob/v7.0.0.rc1/activerecord/CHANGELOG.md
-  documentation_uri: https://api.rubyonrails.org/v7.0.0.rc1/
+  changelog_uri: https://github.com/rails/rails/blob/v7.0.1/activerecord/CHANGELOG.md
+  documentation_uri: https://api.rubyonrails.org/v7.0.1/
   mailing_list_uri: https://discuss.rubyonrails.org/c/rubyonrails-talk
-  source_code_uri: https://github.com/rails/rails/tree/v7.0.0.rc1/activerecord
+  source_code_uri: https://github.com/rails/rails/tree/v7.0.1/activerecord
   rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options:
@@ -450,11 +452,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.32
 signing_key: 
 specification_version: 4
 summary: Object-relational mapper framework (part of Rails).