activerecord 6.0.0.beta3 → 6.0.2.rc2

data/lib/active_record/connection_handling.rb

@@ -85,14 +85,14 @@ module ActiveRecord
     # based on the requested role:
     #
     #   ActiveRecord::Base.connected_to(role: :writing) do
-    #     Dog.create! # creates dog using dog connection
+    #     Dog.create! # creates dog using dog writing connection
     #   end
     #
     #   ActiveRecord::Base.connected_to(role: :reading) do
     #     Dog.create! # throws exception because we're on a replica
     #   end
     #
-    #   ActiveRecord::Base.connected_to(role: :unknown_ode) do
+    #   ActiveRecord::Base.connected_to(role: :unknown_role) do
     #     # raises exception due to non-existent role
     #   end
     #
@@ -100,31 +100,44 @@ module ActiveRecord
     # you can use +connected_to+ with a +database+ argument. The +database+ argument
     # expects a symbol that corresponds to the database key in your config.
     #
-    # This will connect to a new database for the queries inside the block.
-    #
     #   ActiveRecord::Base.connected_to(database: :animals_slow_replica) do
     #     Dog.run_a_long_query # runs a long query while connected to the +animals_slow_replica+
     #   end
-    def connected_to(database: nil, role: nil, &blk)
+    #
+    # This will connect to a new database for the queries inside the block. By
+    # default the `:writing` role will be used since all connections must be assigned
+    # a role. If you would like to use a different role you can pass a hash to database:
+    #
+    #   ActiveRecord::Base.connected_to(database: { readonly_slow: :animals_slow_replica }) do
+    #     # runs a long query while connected to the +animals_slow_replica+ using the readonly_slow role.
+    #     Dog.run_a_long_query
+    #   end
+    #
+    # When using the database key a new connection will be established every time. It is not
+    # recommended to use this outside of one-off scripts.
+    def connected_to(database: nil, role: nil, prevent_writes: false, &blk)
       if database && role
         raise ArgumentError, "connected_to can only accept a `database` or a `role` argument, but not both arguments."
       elsif database
         if database.is_a?(Hash)
           role, database = database.first
           role = role.to_sym
-        else
-          role = database.to_sym
         end
 
         config_hash = resolve_config_for_connection(database)
         handler = lookup_connection_handler(role)
 
-        with_handler(role) do
-          handler.establish_connection(config_hash)
-          yield
-        end
+        handler.establish_connection(config_hash)
+
+        with_handler(role, &blk)
       elsif role
-        with_handler(role.to_sym, &blk)
+        if role == writing_role
+          with_handler(role.to_sym) do
+            connection_handler.while_preventing_writes(prevent_writes, &blk)
+          end
+        else
+          with_handler(role.to_sym, &blk)
+        end
       else
         raise ArgumentError, "must provide a `database` or a `role`."
       end
@@ -154,6 +167,7 @@ module ActiveRecord
     end
 
     def lookup_connection_handler(handler_key) # :nodoc:
+      handler_key ||= ActiveRecord::Base.writing_role
       connection_handlers[handler_key] ||= ActiveRecord::ConnectionAdapters::ConnectionHandler.new
     end
 
@@ -166,7 +180,7 @@ module ActiveRecord
       raise "Anonymous class is not allowed." unless name
 
       config_or_env ||= DEFAULT_ENV.call.to_sym
-      pool_name = self == Base ? "primary" : name
+      pool_name = primary_class? ? "primary" : name
       self.connection_specification_name = pool_name
 
       resolver = ConnectionAdapters::ConnectionSpecification::Resolver.new(Base.configurations)
@@ -202,6 +216,10 @@ module ActiveRecord
       @connection_specification_name
     end
 
+    def primary_class? # :nodoc:
+      self == Base || defined?(ApplicationRecord) && self == ApplicationRecord
+    end
+
     # Returns the configuration of the associated connection as a hash:
     #
     #  ActiveRecord::Base.connection_config

data/lib/active_record/core.rb

@@ -101,7 +101,6 @@ module ActiveRecord
       # environment where dumping schema is rarely needed.
       mattr_accessor :dump_schema_after_migration, instance_writer: false, default: true
 
-      mattr_accessor :database_selector, instance_writer: false
       ##
       # :singleton-method:
       # Specifies which database schemas to dump when calling db:structure:dump.
@@ -161,7 +160,7 @@ module ActiveRecord
         return super if block_given? ||
                         primary_key.nil? ||
                         scope_attributes? ||
-                        columns_hash.include?(inheritance_column)
+                        columns_hash.key?(inheritance_column) && !base_class?
 
         id = ids.first
 
@@ -175,14 +174,14 @@ module ActiveRecord
 
         record = statement.execute([id], connection)&.first
         unless record
-          raise RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}",
-                                   name, primary_key, id)
+          raise RecordNotFound.new("Couldn't find #{name} with '#{key}'=#{id}", name, key, id)
         end
         record
       end
 
       def find_by(*args) # :nodoc:
-        return super if scope_attributes? || reflect_on_all_aggregations.any?
+        return super if scope_attributes? || reflect_on_all_aggregations.any? ||
+                        columns_hash.key?(inheritance_column) && !base_class?
 
         hash = args.first
 
@@ -269,7 +268,8 @@ module ActiveRecord
       end
 
       def arel_attribute(name, table = arel_table) # :nodoc:
-        name = attribute_alias(name) if attribute_alias?(name)
+        name = name.to_s
+        name = attribute_aliases[name] || name
         table[name]
       end
 
@@ -317,7 +317,7 @@ module ActiveRecord
     #   # Instantiates a single new object
     #   User.new(first_name: 'Jamie')
     def initialize(attributes = nil)
-      self.class.define_attribute_methods
+      @new_record = true
       @attributes = self.class._default_attributes.deep_dup
 
       init_internals
@@ -354,12 +354,10 @@ module ActiveRecord
     # +attributes+ should be an attributes object, and unlike the
     # `initialize` method, no assignment calls are made per attribute.
     def init_with_attributes(attributes, new_record = false) # :nodoc:
-      init_internals
-
       @new_record = new_record
       @attributes = attributes
 
-      self.class.define_attribute_methods
+      init_internals
 
       yield self if block_given?
 
@@ -398,13 +396,13 @@ module ActiveRecord
     ##
     def initialize_dup(other) # :nodoc:
       @attributes = @attributes.deep_dup
-      @attributes.reset(self.class.primary_key)
+      @attributes.reset(@primary_key)
 
       _run_initialize_callbacks
 
       @new_record               = true
       @destroyed                = false
-      @_start_transaction_state = {}
+      @_start_transaction_state = nil
       @transaction_state        = nil
 
       super
@@ -465,6 +463,7 @@ module ActiveRecord
 
     # Returns +true+ if the attributes hash has been frozen.
     def frozen?
+      sync_with_transaction_state if @transaction_state&.finalized?
       @attributes.frozen?
     end
 
@@ -569,34 +568,34 @@ module ActiveRecord
       end
 
       def init_internals
+        @primary_key              = self.class.primary_key
         @readonly                 = false
         @destroyed                = false
         @marked_for_destruction   = false
         @destroyed_by_association = nil
-        @new_record               = true
-        @_start_transaction_state = {}
+        @_start_transaction_state = nil
         @transaction_state        = nil
-      end
 
-      def initialize_internals_callback
+        self.class.define_attribute_methods
       end
 
-      def thaw
-        if frozen?
-          @attributes = @attributes.dup
-        end
+      def initialize_internals_callback
       end
 
       def custom_inspect_method_defined?
         self.class.instance_method(:inspect).owner != ActiveRecord::Base.instance_method(:inspect).owner
       end
 
+      class InspectionMask < DelegateClass(::String)
+        def pretty_print(pp)
+          pp.text __getobj__
+        end
+      end
+      private_constant :InspectionMask
+
       def inspection_filter
         @inspection_filter ||= begin
-          mask = DelegateClass(::String).new(ActiveSupport::ParameterFilter::FILTERED)
-          def mask.pretty_print(pp)
-            pp.text __getobj__
-          end
+          mask = InspectionMask.new(ActiveSupport::ParameterFilter::FILTERED)
           ActiveSupport::ParameterFilter.new(self.class.filter_attributes, mask: mask)
         end
       end

data/lib/active_record/database_configurations.rb

@@ -7,8 +7,10 @@ require "active_record/database_configurations/url_config"
 module ActiveRecord
   # ActiveRecord::DatabaseConfigurations returns an array of DatabaseConfig
   # objects (either a HashConfig or UrlConfig) that are constructed from the
-  # application's database configuration hash or url string.
+  # application's database configuration hash or URL string.
   class DatabaseConfigurations
+    class InvalidConfigurationError < StandardError; end
+
     attr_reader :configurations
     delegate :any?, to: :configurations
 
@@ -17,22 +19,22 @@ module ActiveRecord
     end
 
     # Collects the configs for the environment and optionally the specification
-    # name passed in. To include replica configurations pass `include_replicas: true`.
+    # name passed in. To include replica configurations pass <tt>include_replicas: true</tt>.
     #
     # If a spec name is provided a single DatabaseConfig object will be
     # returned, otherwise an array of DatabaseConfig objects will be
     # returned that corresponds with the environment and type requested.
     #
-    # Options:
+    # ==== Options
     #
-    # <tt>env_name:</tt> The environment name. Defaults to +nil+ which will collect
-    # configs for all environments.
-    # <tt>spec_name:</tt> The specification name (i.e. primary, animals, etc.). Defaults
-    # to +nil+.
-    # <tt>include_replicas:</tt> Determines whether to include replicas in
-    # the returned list. Most of the time we're only iterating over the write
-    # connection (i.e. migrations don't need to run for the write and read connection).
-    # Defaults to +false+.
+    # * <tt>env_name:</tt> The environment name. Defaults to +nil+ which will collect
+    #   configs for all environments.
+    # * <tt>spec_name:</tt> The specification name (i.e. primary, animals, etc.). Defaults
+    #   to +nil+.
+    # * <tt>include_replicas:</tt> Determines whether to include replicas in
+    #   the returned list. Most of the time we're only iterating over the write
+    #   connection (i.e. migrations don't need to run for the write and read connection).
+    #   Defaults to +false+.
     def configs_for(env_name: nil, spec_name: nil, include_replicas: false)
       configs = env_with_configs(env_name)
 
@@ -53,7 +55,7 @@ module ActiveRecord
 
     # Returns the config hash that corresponds with the environment
     #
-    # If the application has multiple databases `default_hash` will
+    # If the application has multiple databases +default_hash+ will
     # return the first config hash for the environment.
     #
     #   { database: "my_db", adapter: "mysql2" }
@@ -65,7 +67,7 @@ module ActiveRecord
 
     # Returns a single DatabaseConfig object based on the requested environment.
     #
-    # If the application has multiple databases `find_db_config` will return
+    # If the application has multiple databases +find_db_config+ will return
     # the first DatabaseConfig for the environment.
     def find_db_config(env)
       configurations.find do |db_config|
@@ -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.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
+
+        current_env = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_s
 
-        if url = ENV["DATABASE_URL"]
-          build_url_config(url, build_db_config)
-        else
-          build_db_config
+        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.size == 1 && config.values.all? { |v| v.is_a? String })
-          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 original_config = configs.find(&:for_current_env?)
-          if original_config.url_config?
-            configs
-          else
-            configs.map do |config|
-              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/database_configurations/hash_config.rb

@@ -14,16 +14,16 @@ module ActiveRecord
     #   #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
     #     @env_name="development", @spec_name="primary", @config={"database"=>"db_name"}>
     #
-    # Options are:
+    # ==== Options
     #
-    # <tt>:env_name</tt> - The Rails environment, i.e. "development"
-    # <tt>:spec_name</tt> - The specification name. In a standard two-tier
-    # database configuration this will default to "primary". In a multiple
-    # database three-tier database configuration this corresponds to the name
-    # used in the second tier, for example "primary_readonly".
-    # <tt>:config</tt> - The config hash. This is the hash that contains the
-    # database adapter, name, and other important information for database
-    # connections.
+    # * <tt>:env_name</tt> - The Rails environment, i.e. "development".
+    # * <tt>:spec_name</tt> - The specification name. In a standard two-tier
+    #   database configuration this will default to "primary". In a multiple
+    #   database three-tier database configuration this corresponds to the name
+    #   used in the second tier, for example "primary_readonly".
+    # * <tt>:config</tt> - The config hash. This is the hash that contains the
+    #   database adapter, name, and other important information for database
+    #   connections.
     class HashConfig < DatabaseConfig
       attr_reader :config
 
@@ -33,14 +33,14 @@ module ActiveRecord
       end
 
       # Determines whether a database configuration is for a replica / readonly
-      # connection. If the `replica` key is present in the config, `replica?` will
+      # connection. If the +replica+ key is present in the config, +replica?+ will
       # return +true+.
       def replica?
         config["replica"]
       end
 
       # The migrations paths for a database configuration. If the
-      # `migrations_paths` key is present in the config, `migrations_paths`
+      # +migrations_paths+ key is present in the config, +migrations_paths+
       # will return its value.
       def migrations_paths
         config["migrations_paths"]