class ActiveRecord::DatabaseConfigurations::HashConfig

See ActiveRecord::DatabaseConfigurations for more info.
@env_name=“development”, @name=“primary”, @config={database: “db_name”}>
#<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10
Becomes:
{ “development” => { “database” => “db_name” } }
A hash config:
is created from a hash.
A HashConfig object is created for each database configuration entry that
= Active Record Database Hash Config

def _database=(database) # :nodoc:

:nodoc: 
def _database=(database) # :nodoc:
  @configuration_hash = configuration_hash.merge(database: database).freeze
end

def adapter 

def adapter
  configuration_hash[:adapter]
end

def checkout_timeout 

def checkout_timeout
  (configuration_hash[:checkout_timeout] || 5).to_f
end

def database 

def database
  configuration_hash[:database]
end

def database_tasks? # :nodoc:

:nodoc: 
def database_tasks? # :nodoc:
  !replica? && !!configuration_hash.fetch(:database_tasks, true)
end

def default_schema_cache_path(db_dir = "db") 

def default_schema_cache_path(db_dir = "db")
  if primary?
    File.join(db_dir, "schema_cache.yml")
  else
    File.join(db_dir, "#{name}_schema_cache.yml")
  end
end

def host 

def host
  configuration_hash[:host]
end

def idle_timeout 

def idle_timeout
  timeout = configuration_hash.fetch(:idle_timeout, 300).to_f
  timeout if timeout > 0
end

def initialize(env_name, name, configuration_hash)

connections.
database adapter, name, and other important information for database
* :config - The config hash. This is the hash that contains the
used in the second tier, for example "primary_readonly".
database three-tier database configuration this corresponds to the name
database configuration this will default to "primary". In a multiple
* :name - The db config name. In a standard two-tier
* :env_name - The \Rails environment, i.e. "development".

==== Options

Initialize a new +HashConfig+ object 
def initialize(env_name, name, configuration_hash)
  super(env_name, name)
  @configuration_hash = configuration_hash.symbolize_keys.freeze
end

def lazy_schema_cache_path 

def lazy_schema_cache_path
  schema_cache_path || default_schema_cache_path
end

def max_queue 

def max_queue
  max_threads * 4
end

def max_threads 

def max_threads
  (configuration_hash[:max_threads] || pool).to_i
end

def migrations_paths

will return its value.
+migrations_paths+ key is present in the config, +migrations_paths+
The migrations paths for a database configuration. If the 
def migrations_paths
  configuration_hash[:migrations_paths]
end

def min_threads 

def min_threads
  (configuration_hash[:min_threads] || 0).to_i
end

def pool 

def pool
  (configuration_hash[:pool] || 5).to_i
end

def primary? # :nodoc:

:nodoc: 
def primary? # :nodoc:
  Base.configurations.primary?(name)
end

def query_cache 

def query_cache
  configuration_hash[:query_cache]
end

def reaping_frequency

also be useful if someone wants a very low +idle_timeout+.
+reaping_frequency+ is configurable mostly for historical reasons, but it could 
def reaping_frequency
  configuration_hash.fetch(:reaping_frequency, 60)&.to_f
end

def replica?

return +true+.
connection. If the +replica+ key is present in the config, +replica?+ will
Determines whether a database configuration is for a replica / readonly 
def replica?
  configuration_hash[:replica]
end

def schema_cache_path

default will be derived.
If omitted, the filename will be read from ENV or a
The path to the schema cache dump file for a database. 
def schema_cache_path
  configuration_hash[:schema_cache_path]
end

def schema_dump(format = ActiveRecord.schema_format)

will generate the filename from the database config name.
If the config option is set that will be used. Otherwise \Rails

the schema will not be dumped.
If +configuration_hash[:schema_dump]+ is set to +false+ or +nil+

filename that should be used.
Determines whether to dump the schema/structure files and the 
def schema_dump(format = ActiveRecord.schema_format)
  if configuration_hash.key?(:schema_dump)
    if config = configuration_hash[:schema_dump]
      config
    end
  elsif primary?
    schema_file_type(format)
  else
    "#{name}_#{schema_file_type(format)}"
  end
end

def schema_file_type(format) 

def schema_file_type(format)
  case format
  when :ruby
    "schema.rb"
  when :sql
    "structure.sql"
  end
end

def socket # :nodoc:

:nodoc: 
def socket # :nodoc:
  configuration_hash[:socket]
end