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:
created from a hash.
A ‘HashConfig` object is created for each database configuration entry that is
# 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]&.to_s
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
* `configuration_hash` - The config hash. This is the hash that contains the
example "primary_readonly".
configuration this corresponds to the name used in the second tier, for
this will default to "primary". In a multiple database three-tier database
* `name` - The db config name. In a standard two-tier database configuration
* `env_name` - The Rails environment, i.e. "development".

#### Parameters

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

key is present in the config, `migrations_paths` will return its value.
The migrations paths for a database configuration. If the `migrations_paths` 
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

could also be useful if someone wants a very low `idle_timeout`.
`reaping_frequency` is configurable mostly for historical reasons, but it 
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

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

def schema_dump(format = ActiveRecord.schema_format)

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

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

should be used.
Determines whether to dump the schema/structure files and the filename that 
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 seeds?

will return `true` for the primary database and `false` for all other configs.
If the `seeds` key is present in the config, `seeds?` will return its value. Otherwise, it

Determines whether the db:prepare task should seed the database from db/seeds.rb. 
def seeds?
  configuration_hash.fetch(:seeds, primary?)
end

def socket # :nodoc:

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

def use_metadata_table? # :nodoc:

:nodoc: 
def use_metadata_table? # :nodoc:
  configuration_hash.fetch(:use_metadata_table, true)
end