activerecord 6.0.0.rc2 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97bc72165e9eb1685576780f439be5be8894b7c589cc890d8c6340b8125de0a4
-  data.tar.gz: 74d58cd2f64976ef8faa42a02e94e6d9c9356fce3f0f2c219f7377a09712e7a4
+  metadata.gz: ed17e948626d108075b2951ac71abbac3075ef55b055abe64e2b352e91755fd9
+  data.tar.gz: 2c031642e021041f9fdf278888b580fd446879008a23f12d33c8b33aafbddc59
 SHA512:
-  metadata.gz: 5306d17e736a64c87fc0115299b055c58343df4d18a53d532b09e570d6cc799abf84b4149deef9c03f56563ed23ee563cf57d03fc6c65529e9a6aa0324ca1614
-  data.tar.gz: 6fe8094ad7c0d0433c23691e372417124bddf17659c4bcb64b0bca5af0513d2c9b8599cfe0c244d28649529ab64b99c4a74b638bdf5ab9b4932c276a287d1e78
+  metadata.gz: 6b208a5cbee77c2a057649b762a92ec4ca5be3b8fbd1b2123caf485579abbc602bcb2aee455a503b74f33efa9ce364ab644dc8958b9e1edd94fee3397bf17cc8
+  data.tar.gz: 751ecf72279d478887665f6a3efc5ad366b70284fb3f4ef6d2f3b072faf7c325be660116a7d3ac9427ac44dcf6f8c345e145921692d0465e24a70f1c2ca3b1bd

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## Rails 6.0.0 (August 16, 2019) ##
+
+*   Preserve user supplied joins order as much as possible.
+
+    Fixes #36761, #34328, #24281, #12953.
+
+    *Ryuta Kamizono*
+
+*   Make the DATABASE_URL env variable only affect the primary connection. Add new env variables for multiple databases.
+
+    *John Crepezzi*, *Eileen Uchitelle*
+
+*   Add a warning for enum elements with 'not_' prefix.
+
+        class Foo
+          enum status: [:sent, :not_sent]
+        end
+
+    *Edu Depetris*
+
+*   Make currency symbols optional for money column type in PostgreSQL
+
+    *Joel Schneider*
+
+
 ## Rails 6.0.0.rc2 (July 22, 2019) ##
 
 *   Add database_exists? method to connection adapters to check if a database exists.
@@ -386,7 +411,7 @@
     `GET` and `HEAD` requests will read from the replica unless there was
     a write in the last 2 seconds, otherwise they will read from the primary.
     Non-get requests will always write to the primary. The middleware accepts
-    an argument for a Resolver class and a Operations class where you are able
+    an argument for a Resolver class and an Operations class where you are able
     to change how the auto-switcher works to be most beneficial for your
     application.
 
@@ -820,7 +845,7 @@
     *Darwin Wu*
 
 *   Configuration item `config.filter_parameters` could also filter out
-    sensitive values of database columns when call `#inspect`.
+    sensitive values of database columns when calling `#inspect`.
     We also added `ActiveRecord::Base::filter_attributes`/`=` in order to
     specify sensitive attributes to specific model.
 

data/lib/active_record/associations/builder/has_and_belongs_to_many.rb

@@ -63,7 +63,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join("_").gsub("::", "_").to_sym
+                     association_name.to_s].sort.join("_").gsub("::", "_").to_sym
       middle_options = middle_options join_model
 
       HasMany.create_reflection(lhs_model,

data/lib/active_record/autosave_association.rb

@@ -304,7 +304,7 @@ module ActiveRecord
       def validate_single_association(reflection)
         association = association_instance_get(reflection.name)
         record      = association && association.reader
-        association_valid?(reflection, record) if record
+        association_valid?(reflection, record) if record && record.changed_for_autosave?
       end
 
       # Validate the associated records if <tt>:validate</tt> or

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

@@ -1005,28 +1005,33 @@ module ActiveRecord
         end
       end
 
-      attr_reader :prevent_writes
-
       def initialize
         # These caches are keyed by spec.name (ConnectionSpecification#name).
         @owner_to_pool = ConnectionHandler.create_owner_to_pool
-        @prevent_writes = false
 
         # Backup finalizer: if the forked child never needed a pool, the above
         # early discard has not occurred
         ObjectSpace.define_finalizer self, ConnectionHandler.unowned_pool_finalizer(@owner_to_pool)
       end
 
+      def prevent_writes # :nodoc:
+        Thread.current[:prevent_writes]
+      end
+
+      def prevent_writes=(prevent_writes) # :nodoc:
+        Thread.current[:prevent_writes] = prevent_writes
+      end
+
       # Prevent writing to the database regardless of role.
       #
       # In some cases you may want to prevent writes to the database
       # even if you are on a database that can write. `while_preventing_writes`
       # will prevent writes to the database for the duration of the block.
-      def while_preventing_writes
-        original, @prevent_writes = @prevent_writes, true
+      def while_preventing_writes(enabled = true)
+        original, self.prevent_writes = self.prevent_writes, enabled
         yield
       ensure
-        @prevent_writes = original
+        self.prevent_writes = original
       end
 
       def connection_pool_list

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

@@ -101,7 +101,7 @@ module ActiveRecord
       def index_exists?(table_name, column_name, options = {})
         column_names = Array(column_name).map(&:to_s)
         checks = []
-        checks << lambda { |i| i.columns == column_names }
+        checks << lambda { |i| Array(i.columns) == column_names }
         checks << lambda { |i| i.unique } if options[:unique]
         checks << lambda { |i| i.name == options[:name].to_s } if options[:name]
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -11,6 +11,7 @@ require "arel/collectors/bind"
 require "arel/collectors/composite"
 require "arel/collectors/sql_string"
 require "arel/collectors/substitute_binds"
+require "concurrent/atomic/thread_local_var"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -78,7 +79,7 @@ module ActiveRecord
       SIMPLE_INT = /\A\d+\z/
 
       attr_accessor :pool
-      attr_reader :visitor, :owner, :logger, :lock, :prepared_statements
+      attr_reader :visitor, :owner, :logger, :lock
       alias :in_use? :owner
 
       set_callback :checkin, :after, :enable_lazy_transactions!
@@ -129,10 +130,10 @@ module ActiveRecord
         @lock = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
 
         if self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements) { true })
-          @prepared_statements = true
+          @prepared_statement_status = Concurrent::ThreadLocalVar.new(true)
           @visitor.extend(DetermineIfPreparableVisitor)
         else
-          @prepared_statements = false
+          @prepared_statement_status = Concurrent::ThreadLocalVar.new(false)
         end
 
         @advisory_locks_enabled = self.class.type_cast_config_to_boolean(
@@ -175,6 +176,10 @@ module ActiveRecord
                               end
       end
 
+      def prepared_statements
+        @prepared_statement_status.value
+      end
+
       class Version
         include Comparable
 
@@ -259,10 +264,7 @@ module ActiveRecord
       end
 
       def unprepared_statement
-        old_prepared_statements, @prepared_statements = @prepared_statements, false
-        yield
-      ensure
-        @prepared_statements = old_prepared_statements
+        @prepared_statement_status.bind(false) { yield }
       end
 
       # Returns the human-readable name of the adapter. Use mixed case - one

data/lib/active_record/connection_adapters/connection_specification.rb

@@ -222,7 +222,7 @@ module ActiveRecord
             when Hash
               resolve_hash_connection config_or_env
             else
-              resolve_connection config_or_env
+              raise TypeError, "Invalid type for configuration. Expected Symbol, String, or Hash. Got #{config_or_env.inspect}"
             end
           end
 

data/lib/active_record/connection_adapters/mysql2_adapter.rb

@@ -39,8 +39,8 @@ module ActiveRecord
       include MySQL::DatabaseStatements
 
       def initialize(connection, logger, connection_options, config)
-        super
-        @prepared_statements = false unless config.key?(:prepared_statements)
+        superclass_config = config.reverse_merge(prepared_statements: false)
+        super(connection, logger, connection_options, superclass_config)
         configure_connection
       end
 

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

@@ -26,9 +26,9 @@ module ActiveRecord
 
             value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
-            when /^-?\D+[\d,]+\.\d{2}$/  # (1)
+            when /^-?\D*[\d,]+\.\d{2}$/  # (1)
               value.gsub!(/[^-\d.]/, "")
-            when /^-?\D+[\d.]+,\d{2}$/  # (2)
+            when /^-?\D*[\d.]+,\d{2}$/  # (2)
               value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
             end
 

data/lib/active_record/database_configurations.rb

@@ -9,6 +9,8 @@ module ActiveRecord
   # objects (either a HashConfig or UrlConfig) that are constructed from the
   # application's database configuration hash or URL string.
   class DatabaseConfigurations
+    class InvalidConfigurationError < StandardError; end
+
     attr_reader :configurations
     delegate :any?, to: :configurations
 
@@ -91,6 +93,19 @@ module ActiveRecord
     end
     alias :blank? :empty?
 
+    def each
+      throw_getter_deprecation(:each)
+      configurations.each { |config|
+        yield [config.env_name, config.config]
+      }
+    end
+
+    def first
+      throw_getter_deprecation(:first)
+      config = configurations.first
+      [config.env_name, config.config]
+    end
+
     private
       def env_with_configs(env = nil)
         if env
@@ -104,34 +119,48 @@ module ActiveRecord
         return configs.configurations if configs.is_a?(DatabaseConfigurations)
         return configs if configs.is_a?(Array)
 
-        build_db_config = configs.each_pair.flat_map do |env_name, config|
-          walk_configs(env_name.to_s, "primary", config)
-        end.flatten.compact
+        db_configs = configs.flat_map do |env_name, config|
+          if config.is_a?(Hash) && config.all? { |_, v| v.is_a?(Hash) }
+            walk_configs(env_name.to_s, config)
+          else
+            build_db_config_from_raw_config(env_name.to_s, "primary", config)
+          end
+        end
 
-        if url = ENV["DATABASE_URL"]
-          build_url_config(url, build_db_config)
-        else
-          build_db_config
+        current_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s
+
+        unless db_configs.find(&:for_current_env?)
+          db_configs << environment_url_config(current_env, "primary", {})
+        end
+
+        merge_db_environment_variables(current_env, db_configs.compact)
+      end
+
+      def walk_configs(env_name, config)
+        config.map do |spec_name, sub_config|
+          build_db_config_from_raw_config(env_name, spec_name.to_s, sub_config)
         end
       end
 
-      def walk_configs(env_name, spec_name, config)
+      def build_db_config_from_raw_config(env_name, spec_name, config)
         case config
         when String
           build_db_config_from_string(env_name, spec_name, config)
         when Hash
           build_db_config_from_hash(env_name, spec_name, config.stringify_keys)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
         end
       end
 
       def build_db_config_from_string(env_name, spec_name, config)
         url = config
         uri = URI.parse(url)
-        if uri.try(:scheme)
+        if uri.scheme
           ActiveRecord::DatabaseConfigurations::UrlConfig.new(env_name, spec_name, url)
+        else
+          raise InvalidConfigurationError, "'{ #{env_name} => #{config} }' is not a valid configuration. Expected '#{config}' to be a URL string or a Hash."
         end
-      rescue URI::InvalidURIError
-        ActiveRecord::DatabaseConfigurations::HashConfig.new(env_name, spec_name, config)
       end
 
       def build_db_config_from_hash(env_name, spec_name, config)
@@ -141,36 +170,36 @@ module ActiveRecord
           config_without_url.delete "url"
 
           ActiveRecord::DatabaseConfigurations::UrlConfig.new(env_name, spec_name, url, config_without_url)
-        elsif config["database"] || config["adapter"] || ENV["DATABASE_URL"]
-          ActiveRecord::DatabaseConfigurations::HashConfig.new(env_name, spec_name, config)
         else
-          config.each_pair.map do |sub_spec_name, sub_config|
-            walk_configs(env_name, sub_spec_name, sub_config)
-          end
+          ActiveRecord::DatabaseConfigurations::HashConfig.new(env_name, spec_name, config)
         end
       end
 
-      def build_url_config(url, configs)
-        env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s
+      def merge_db_environment_variables(current_env, configs)
+        configs.map do |config|
+          next config if config.url_config? || config.env_name != current_env
 
-        if configs.find(&:for_current_env?)
-          configs.map do |config|
-            if config.url_config?
-              config
-            else
-              ActiveRecord::DatabaseConfigurations::UrlConfig.new(config.env_name, config.spec_name, url, config.config)
-            end
-          end
-        else
-          configs + [ActiveRecord::DatabaseConfigurations::UrlConfig.new(env, "primary", url)]
+          url_config = environment_url_config(current_env, config.spec_name, config.config)
+          url_config || config
         end
       end
 
+      def environment_url_config(env, spec_name, config)
+        url = environment_value_for(spec_name)
+        return unless url
+
+        ActiveRecord::DatabaseConfigurations::UrlConfig.new(env, spec_name, url, config)
+      end
+
+      def environment_value_for(spec_name)
+        spec_env_key = "#{spec_name.upcase}_DATABASE_URL"
+        url = ENV[spec_env_key]
+        url ||= ENV["DATABASE_URL"] if spec_name == "primary"
+        url
+      end
+
       def method_missing(method, *args, &blk)
         case method
-        when :each, :first
-          throw_getter_deprecation(method)
-          configurations.send(method, *args, &blk)
         when :fetch
           throw_getter_deprecation(method)
           configs_for(env_name: args.first)

data/lib/active_record/enum.rb

@@ -200,6 +200,8 @@ module ActiveRecord
             # scope :active, -> { where(status: 0) }
             # scope :not_active, -> { where.not(status: 0) }
             if enum_scopes != false
+              klass.send(:detect_negative_condition!, value_method_name)
+
               klass.send(:detect_enum_conflict!, name, value_method_name, true)
               klass.scope value_method_name, -> { where(attr => value) }
 
@@ -261,5 +263,12 @@ module ActiveRecord
           source: source
         }
       end
+
+      def detect_negative_condition!(method_name)
+        if method_name.start_with?("not_") && logger
+          logger.warn "An enum element in #{self.name} uses the prefix 'not_'." \
+            " This will cause a conflict with auto generated negative scopes."
+        end
+      end
   end
 end

data/lib/active_record/fixtures.rb

@@ -531,15 +531,15 @@ module ActiveRecord
         end
       end
 
-      def create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base)
+      def create_fixtures(fixtures_directory, fixture_set_names, class_names = {}, config = ActiveRecord::Base, &block)
         fixture_set_names = Array(fixture_set_names).map(&:to_s)
         class_names = ClassCache.new class_names, config
 
         # FIXME: Apparently JK uses this.
-        connection = block_given? ? yield : ActiveRecord::Base.connection
+        connection = block_given? ? block : lambda { ActiveRecord::Base.connection }
 
         fixture_files_to_read = fixture_set_names.reject do |fs_name|
-          fixture_is_cached?(connection, fs_name)
+          fixture_is_cached?(connection.call, fs_name)
         end
 
         if fixture_files_to_read.any?
@@ -549,9 +549,9 @@ module ActiveRecord
             class_names,
             connection,
           )
-          cache_fixtures(connection, fixtures_map)
+          cache_fixtures(connection.call, fixtures_map)
         end
-        cached_fixtures(connection, fixture_set_names)
+        cached_fixtures(connection.call, fixture_set_names)
       end
 
       # Returns a consistent, platform-independent identifier for +label+.
@@ -591,7 +591,11 @@ module ActiveRecord
 
         def insert(fixture_sets, connection) # :nodoc:
           fixture_sets_by_connection = fixture_sets.group_by do |fixture_set|
-            fixture_set.model_class&.connection || connection
+            if fixture_set.model_class
+              fixture_set.model_class.connection
+            else
+              connection.call
+            end
           end
 
           fixture_sets_by_connection.each do |conn, set|
@@ -602,6 +606,7 @@ module ActiveRecord
                 table_rows_for_connection[table].unshift(*rows)
               end
             end
+
             conn.insert_fixtures_set(table_rows_for_connection, table_rows_for_connection.keys)
 
             # Cap primary key sequences to max(pk).

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 6
     MINOR = 0
     TINY  = 0
-    PRE   = "rc2"
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/insert_all.rb

@@ -110,8 +110,7 @@ module ActiveRecord
         end
       end
 
-
-      class Builder
+      class Builder # :nodoc:
         attr_reader :model
 
         delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all

data/lib/active_record/middleware/database_selector/resolver.rb

@@ -47,7 +47,7 @@ module ActiveRecord
 
           def read_from_primary(&blk)
             ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role) do
-              ActiveRecord::Base.connection_handler.while_preventing_writes do
+              ActiveRecord::Base.connection_handler.while_preventing_writes(true) do
                 instrumenter.instrument("database_selector.active_record.read_from_primary") do
                   yield
                 end
@@ -65,10 +65,12 @@ module ActiveRecord
 
           def write_to_primary(&blk)
             ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role) do
-              instrumenter.instrument("database_selector.active_record.wrote_to_primary") do
-                yield
-              ensure
-                context.update_last_write_timestamp
+              ActiveRecord::Base.connection_handler.while_preventing_writes(false) do
+                instrumenter.instrument("database_selector.active_record.wrote_to_primary") do
+                  yield
+                ensure
+                  context.update_last_write_timestamp
+                end
               end
             end
           end

data/lib/active_record/migration.rb

@@ -588,18 +588,26 @@ module ActiveRecord
       end
 
       def load_schema_if_pending!
-        if Base.connection.migration_context.needs_migration? || !Base.connection.migration_context.any_migrations?
+        current_config = Base.connection_config
+        all_configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
+
+        needs_update = !all_configs.all? do |db_config|
+          Tasks::DatabaseTasks.schema_up_to_date?(db_config.config, ActiveRecord::Base.schema_format, nil, Rails.env, db_config.spec_name)
+        end
+
+        if needs_update
           # Roundtrip to Rake to allow plugins to hook into database initialization.
           root = defined?(ENGINE_ROOT) ? ENGINE_ROOT : Rails.root
           FileUtils.cd(root) do
-            current_config = Base.connection_config
             Base.clear_all_connections!
             system("bin/rails db:test:prepare")
-            # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
-            Base.establish_connection(current_config)
           end
-          check_pending!
         end
+
+        # Establish a new connection, the old database may be gone (db:test:prepare uses purge)
+        Base.establish_connection(current_config)
+
+        check_pending!
       end
 
       def maintain_test_schema! #:nodoc:

data/lib/active_record/railties/databases.rake

@@ -265,6 +265,8 @@ db_namespace = namespace :db do
       end
       abort %{Run `rails db:migrate` to update your database then try again.}
     end
+  ensure
+    ActiveRecord::Base.establish_connection(ActiveRecord::Tasks::DatabaseTasks.env.to_sym)
   end
 
   namespace :abort_if_pending_migrations do
@@ -297,10 +299,11 @@ db_namespace = namespace :db do
     ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
       ActiveRecord::Base.establish_connection(db_config.config)
 
-      ActiveRecord::Tasks::DatabaseTasks.migrate
-
       # Skipped when no database
-      ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config.config, ActiveRecord::Base.schema_format, db_config.spec_name)
+      ActiveRecord::Tasks::DatabaseTasks.migrate
+      if ActiveRecord::Base.dump_schema_after_migration
+        ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config.config, ActiveRecord::Base.schema_format, db_config.spec_name)
+      end
 
     rescue ActiveRecord::NoDatabaseError
       ActiveRecord::Tasks::DatabaseTasks.create_current(db_config.env_name, db_config.spec_name)

data/lib/active_record/relation/calculations.rb

@@ -321,7 +321,7 @@ module ActiveRecord
         }
         group_columns = group_aliases.zip(group_fields)
 
-        aggregate_alias = column_alias_for("#{operation}_#{column_name.to_s.downcase}")
+        aggregate_alias = column_alias_for("#{operation} #{column_name.to_s.downcase}")
 
         select_values = [
           operation_over_aggregate_column(
@@ -374,8 +374,6 @@ module ActiveRecord
       #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
       #   column_alias_for("count(*)")                 # => "count_all"
       def column_alias_for(field)
-        return field if field.match?(/\A\w{,#{connection.table_alias_length}}\z/)
-
         column_alias = +field
         column_alias.gsub!(/\*/, "all")
         column_alias.gsub!(/\W+/, " ")

data/lib/active_record/relation/query_methods.rb

@@ -372,7 +372,7 @@ module ActiveRecord
 
     # Same as #reorder but operates on relation in-place instead of copying.
     def reorder!(*args) # :nodoc:
-      preprocess_order_args(args)
+      preprocess_order_args(args) unless args.all?(&:blank?)
 
       self.reordering_value = true
       self.order_values = args
@@ -1095,26 +1095,44 @@ module ActiveRecord
       end
 
       def build_left_outer_joins(manager, outer_joins, aliases)
-        buckets = { association_join: valid_association_list(outer_joins) }
+        buckets = Hash.new { |h, k| h[k] = [] }
+        buckets[:association_join] = valid_association_list(outer_joins)
         build_join_query(manager, buckets, Arel::Nodes::OuterJoin, aliases)
       end
 
       def build_joins(manager, joins, aliases)
+        buckets = Hash.new { |h, k| h[k] = [] }
+
         unless left_outer_joins_values.empty?
           left_joins = valid_association_list(left_outer_joins_values.flatten)
-          joins.unshift construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
+          buckets[:stashed_join] << construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
+        end
+
+        joins.map! do |join|
+          if join.is_a?(String)
+            table.create_string_join(Arel.sql(join.strip)) unless join.blank?
+          else
+            join
+          end
+        end.delete_if(&:blank?).uniq!
+
+        while joins.first.is_a?(Arel::Nodes::Join)
+          join_node = joins.shift
+          if join_node.is_a?(Arel::Nodes::StringJoin) && !buckets[:stashed_join].empty?
+            buckets[:join_node] << join_node
+          else
+            buckets[:leading_join] << join_node
+          end
         end
 
-        buckets = joins.group_by do |join|
+        joins.each do |join|
           case join
-          when String
-            :string_join
           when Hash, Symbol, Array
-            :association_join
+            buckets[:association_join] << join
           when ActiveRecord::Associations::JoinDependency
-            :stashed_join
+            buckets[:stashed_join] << join
           when Arel::Nodes::Join
-            :join_node
+            buckets[:join_node] << join
           else
             raise "unknown class: %s" % join.class.name
           end
@@ -1124,25 +1142,21 @@ module ActiveRecord
       end
 
       def build_join_query(manager, buckets, join_type, aliases)
-        buckets.default = []
-
         association_joins = buckets[:association_join]
         stashed_joins     = buckets[:stashed_join]
-        join_nodes        = buckets[:join_node].tap(&:uniq!)
-        string_joins      = buckets[:string_join].delete_if(&:blank?).map!(&:strip).tap(&:uniq!)
-
-        string_joins.map! { |join| table.create_string_join(Arel.sql(join)) }
+        leading_joins     = buckets[:leading_join]
+        join_nodes        = buckets[:join_node]
 
         join_sources = manager.join_sources
-        join_sources.concat(join_nodes) unless join_nodes.empty?
+        join_sources.concat(leading_joins) unless leading_joins.empty?
 
         unless association_joins.empty? && stashed_joins.empty?
-          alias_tracker = alias_tracker(join_nodes + string_joins, aliases)
+          alias_tracker = alias_tracker(leading_joins + join_nodes, aliases)
           join_dependency = construct_join_dependency(association_joins, join_type)
           join_sources.concat(join_dependency.join_constraints(stashed_joins, alias_tracker))
         end
 
-        join_sources.concat(string_joins) unless string_joins.empty?
+        join_sources.concat(join_nodes) unless join_nodes.empty?
       end
 
       def build_select(arel)

data/lib/active_record/tasks/database_tasks.rb

@@ -154,6 +154,8 @@ module ActiveRecord
       end
 
       def for_each(databases)
+        return {} unless defined?(Rails)
+
         database_configs = ActiveRecord::DatabaseConfigurations.new(databases).configs_for(env_name: Rails.env)
 
         # if this is a single database application we don't want tasks for each primary database
@@ -331,10 +333,39 @@ module ActiveRecord
         end
         ActiveRecord::InternalMetadata.create_table
         ActiveRecord::InternalMetadata[:environment] = environment
+        ActiveRecord::InternalMetadata[:schema_sha1] = schema_sha1(file)
       ensure
         Migration.verbose = verbose_was
       end
 
+      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary")
+        file ||= dump_filename(spec_name, format)
+
+        return true unless File.exist?(file)
+
+        ActiveRecord::Base.establish_connection(configuration)
+        return false unless ActiveRecord::InternalMetadata.table_exists?
+        ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
+      end
+
+      def reconstruct_from_schema(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = env, spec_name = "primary") # :nodoc:
+        file ||= dump_filename(spec_name, format)
+
+        check_schema_file(file)
+
+        ActiveRecord::Base.establish_connection(configuration)
+
+        if schema_up_to_date?(configuration, format, file, environment, spec_name)
+          truncate_tables(configuration)
+        else
+          purge(configuration)
+          load_schema(configuration, format, file, environment, spec_name)
+        end
+      rescue ActiveRecord::NoDatabaseError
+        create(configuration)
+        load_schema(configuration, format, file, environment, spec_name)
+      end
+
       def dump_schema(configuration, format = ActiveRecord::Base.schema_format, spec_name = "primary") # :nodoc:
         require "active_record/schema_dumper"
         filename = dump_filename(spec_name, format)
@@ -466,6 +497,10 @@ module ActiveRecord
         def local_database?(configuration)
           configuration["host"].blank? || LOCAL_HOSTS.include?(configuration["host"])
         end
+
+        def schema_sha1(file)
+          Digest::SHA1.hexdigest(File.read(file))
+        end
     end
   end
 end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -16,7 +16,7 @@ module ActiveRecord
         connection.create_database configuration["database"], creation_options
         establish_connection configuration
       rescue ActiveRecord::StatementInvalid => error
-        if error.cause.error_number == ER_DB_CREATE_EXISTS
+        if connection.error_number(error.cause) == ER_DB_CREATE_EXISTS
           raise DatabaseAlreadyExists
         else
           raise

data/lib/active_record/test_databases.rb

@@ -8,31 +8,16 @@ module ActiveRecord
       create_and_load_schema(i, env_name: Rails.env)
     end
 
-    ActiveSupport::Testing::Parallelization.run_cleanup_hook do
-      drop(env_name: Rails.env)
-    end
-
     def self.create_and_load_schema(i, env_name:)
       old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
 
       ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
         db_config.config["database"] += "-#{i}"
-        ActiveRecord::Tasks::DatabaseTasks.create(db_config.config)
-        ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config.config, ActiveRecord::Base.schema_format, nil, env_name, db_config.spec_name)
+        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config.config, ActiveRecord::Base.schema_format, nil, env_name, db_config.spec_name)
       end
     ensure
       ActiveRecord::Base.establish_connection(Rails.env.to_sym)
       ENV["VERBOSE"] = old
     end
-
-    def self.drop(env_name:)
-      old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
-
-      ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
-        ActiveRecord::Tasks::DatabaseTasks.drop(db_config.config)
-      end
-    ensure
-      ENV["VERBOSE"] = old
-    end
   end
 end

data/lib/active_record/validations.rb

@@ -40,6 +40,7 @@ module ActiveRecord
     include ActiveModel::Validations
 
     # The validation process on save can be skipped by passing <tt>validate: false</tt>.
+    # The validation context can be changed by passing <tt>context: context</tt>.
     # The regular {ActiveRecord::Base#save}[rdoc-ref:Persistence#save] method is replaced
     # with this when the validations module is mixed in, which it is by default.
     def save(options = {})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord
 version: !ruby/object:Gem::Version
-  version: 6.0.0.rc2
+  version: 6.0.0
 platform: ruby
 authors:
 - David Heinemeier Hansson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-22 00:00:00.000000000 Z
+date: 2019-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.rc2
+        version: 6.0.0
 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.
@@ -389,8 +389,8 @@ homepage: https://rubyonrails.org
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/rails/rails/tree/v6.0.0.rc2/activerecord
-  changelog_uri: https://github.com/rails/rails/blob/v6.0.0.rc2/activerecord/CHANGELOG.md
+  source_code_uri: https://github.com/rails/rails/tree/v6.0.0/activerecord
+  changelog_uri: https://github.com/rails/rails/blob/v6.0.0/activerecord/CHANGELOG.md
 post_install_message: 
 rdoc_options:
 - "--main"
@@ -404,9 +404,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.1
 signing_key: