Module: ActiveRecord::Core

# File 'activerecord/lib/active_record/core.rb', line 13

included do
  ##
  # :singleton-method:
  #
  # Accepts a logger conforming to the interface of Log4r which is then
  # passed on to any new database connections made and which can be
  # retrieved on both a class and instance level by calling logger.
  mattr_accessor :logger, instance_writer: false

  ##
  # :singleton-method:
  #
  # Specifies if the methods calling database queries should be logged below
  # their relevant queries. Defaults to false.
  mattr_accessor :verbose_query_logs, instance_writer: false, default: false

  ##
  # :singleton-method:
  #
  # Specifies the names of the queues used by background jobs.
  mattr_accessor :queues, instance_accessor: false, default: {}

  ##
  # :singleton-method:
  #
  # Specifies the job used to destroy associations in the background
  class_attribute :destroy_association_async_job, instance_writer: false, instance_predicate: false, default: false

  ##
  # Contains the database configuration - as is typically stored in config/database.yml -
  # as an ActiveRecord::DatabaseConfigurations object.
  #
  # For example, the following database.yml...
  #
  #   development:
  #     adapter: sqlite3
  #     database: db/development.sqlite3
  #
  #   production:
  #     adapter: sqlite3
  #     database: db/production.sqlite3
  #
  # ...would result in ActiveRecord::Base.configurations to look like this:
  #
  #   #<ActiveRecord::DatabaseConfigurations:0x00007fd1acbdf800 @configurations=[
  #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbded10 @env_name="development",
  #       @name="primary", @config={adapter: "sqlite3", database: "db/development.sqlite3"}>,
  #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbdea90 @env_name="production",
  #       @name="primary", @config={adapter: "sqlite3", database: "db/production.sqlite3"}>
  #   ]>
  def self.configurations=(config)
    @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
  end
  self.configurations = {}

  # Returns fully resolved ActiveRecord::DatabaseConfigurations object
  def self.configurations
    @@configurations
  end

  ##
  # :singleton-method:
  # Determines whether to use Time.utc (using :utc) or Time.local (using :local) when pulling
  # dates and times from the database. This is set to :utc by default.
  mattr_accessor :default_timezone, instance_writer: false, default: :utc

  ##
  # :singleton-method:
  # Specifies the format to use when dumping the database schema with Rails'
  # Rakefile. If :sql, the schema is dumped as (potentially database-
  # specific) SQL statements. If :ruby, the schema is dumped as an
  # ActiveRecord::Schema file which can be loaded into any database that
  # supports migrations. Use :ruby if you want to have different database
  # adapters for, e.g., your development and test environments.
  mattr_accessor :schema_format, instance_writer: false, default: :ruby

  ##
  # :singleton-method:
  # Specifies if an error should be raised if the query has an order being
  # ignored when doing batch queries. Useful in applications where the
  # scope being ignored is error-worthy, rather than a warning.
  mattr_accessor :error_on_ignored_order, instance_writer: false, default: false

  ##
  # :singleton-method:
  # Specify whether or not to use timestamps for migration versions
  mattr_accessor :timestamped_migrations, instance_writer: false, default: true

  ##
  # :singleton-method:
  # Specify whether schema dump should happen at the end of the
  # db:migrate rails command. This is true by default, which is useful for the
  # development environment. This should ideally be false in the production
  # environment where dumping schema is rarely needed.
  mattr_accessor :dump_schema_after_migration, instance_writer: false, default: true

  ##
  # :singleton-method:
  # Specifies which database schemas to dump when calling db:schema:dump.
  # If the value is :schema_search_path (the default), any schemas listed in
  # schema_search_path are dumped. Use :all to dump all schemas regardless
  # of schema_search_path, or a string of comma separated schemas for a
  # custom list.
  mattr_accessor :dump_schemas, instance_writer: false, default: :schema_search_path

  ##
  # :singleton-method:
  # Specify a threshold for the size of query result sets. If the number of
  # records in the set exceeds the threshold, a warning is logged. This can
  # be used to identify queries which load thousands of records and
  # potentially cause memory bloat.
  mattr_accessor :warn_on_records_fetched_greater_than, instance_writer: false

  ##
  # :singleton-method:
  # Show a warning when Rails couldn't parse your database.yml
  # for multiple databases.
  mattr_accessor :suppress_multiple_database_warning, instance_writer: false, default: false

  mattr_accessor :maintain_test_schema, instance_accessor: false

  class_attribute :belongs_to_required_by_default, instance_accessor: false

  ##
  # :singleton-method:
  # Set the application to log or raise when an association violates strict loading.
  # Defaults to :raise.
  mattr_accessor :action_on_strict_loading_violation, instance_accessor: false, default: :raise

  class_attribute :strict_loading_by_default, instance_accessor: false, default: false

  mattr_accessor :writing_role, instance_accessor: false, default: :writing

  mattr_accessor :reading_role, instance_accessor: false, default: :reading

  mattr_accessor :has_many_inversing, instance_accessor: false, default: false

  class_attribute :default_connection_handler, instance_writer: false

  class_attribute :default_role, instance_writer: false

  class_attribute :default_shard, instance_writer: false

  mattr_accessor :legacy_connection_handling, instance_writer: false, default: true

  # Application configurable boolean that instructs the YAML Coder to use
  # an unsafe load if set to true.
  mattr_accessor :use_yaml_unsafe_load, instance_writer: false, default: false

  # Application configurable array that provides additional permitted classes
  # to Psych safe_load in the YAML Coder
  mattr_accessor :yaml_column_permitted_classes, instance_writer: false, default: [Symbol]

  ##
  # :singleton-method:
  # Application configurable boolean that denotes whether or not to raise
  # an exception when the PostgreSQLAdapter is provided with an integer that is
  # wider than signed 64bit representation
  mattr_accessor :raise_int_wider_than_64bit, instance_writer: false, default: true

  self.filter_attributes = []

  def self.connection_handler
    Thread.current.thread_variable_get(:ar_connection_handler) || default_connection_handler
  end

  def self.connection_handler=(handler)
    Thread.current.thread_variable_set(:ar_connection_handler, handler)
  end

  def self.connection_handlers
    unless legacy_connection_handling
      raise NotImplementedError, "The new connection handling does not support accessing multiple connection handlers."
    end

    @@connection_handlers ||= {}
  end

  def self.connection_handlers=(handlers)
    unless legacy_connection_handling
      raise NotImplementedError, "The new connection handling does not setting support multiple connection handlers."
    end

    @@connection_handlers = handlers
  end

  # Returns the symbol representing the current connected role.
  #
  #   ActiveRecord::Base.connected_to(role: :writing) do
  #     ActiveRecord::Base.current_role #=> :writing
  #   end
  #
  #   ActiveRecord::Base.connected_to(role: :reading) do
  #     ActiveRecord::Base.current_role #=> :reading
  #   end
  def self.current_role
    if ActiveRecord::Base.legacy_connection_handling
      connection_handlers.key(connection_handler) || default_role
    else
      connected_to_stack.reverse_each do |hash|
        return hash[:role] if hash[:role] && hash[:klasses].include?(Base)
        return hash[:role] if hash[:role] && hash[:klasses].include?(connection_classes)
      end

      default_role
    end
  end

  # Returns the symbol representing the current connected shard.
  #
  #   ActiveRecord::Base.connected_to(role: :reading) do
  #     ActiveRecord::Base.current_shard #=> :default
  #   end
  #
  #   ActiveRecord::Base.connected_to(role: :writing, shard: :one) do
  #     ActiveRecord::Base.current_shard #=> :one
  #   end
  def self.current_shard
    connected_to_stack.reverse_each do |hash|
      return hash[:shard] if hash[:shard] && hash[:klasses].include?(Base)
      return hash[:shard] if hash[:shard] && hash[:klasses].include?(connection_classes)
    end

    default_shard
  end

  # Returns the symbol representing the current setting for
  # preventing writes.
  #
  #   ActiveRecord::Base.connected_to(role: :reading) do
  #     ActiveRecord::Base.current_preventing_writes #=> true
  #   end
  #
  #   ActiveRecord::Base.connected_to(role: :writing) do
  #     ActiveRecord::Base.current_preventing_writes #=> false
  #   end
  def self.current_preventing_writes
    if legacy_connection_handling
      connection_handler.prevent_writes
    else
      connected_to_stack.reverse_each do |hash|
        return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(Base)
        return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(connection_classes)
      end

      false
    end
  end

  def self.connected_to_stack # :nodoc:
    if connected_to_stack = Thread.current.thread_variable_get(:ar_connected_to_stack)
      connected_to_stack
    else
      connected_to_stack = Concurrent::Array.new
      Thread.current.thread_variable_set(:ar_connected_to_stack, connected_to_stack)
      connected_to_stack
    end
  end

  def self.connection_class=(b) # :nodoc:
    @connection_class = b
  end

  def self.connection_class # :nodoc
    @connection_class ||= false
  end

  def self.connection_class? # :nodoc:
    self.connection_class
  end

  def self.connection_classes # :nodoc:
    klass = self

    until klass == Base
      break if klass.connection_class?
      klass = klass.superclass
    end

    klass
  end

  def self.allow_unsafe_raw_sql # :nodoc:
    ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_unsafe_raw_sql is deprecated and will be removed in Rails 7.0")
  end

  def self.allow_unsafe_raw_sql=(value) # :nodoc:
    ActiveSupport::Deprecation.warn("ActiveRecord::Base.allow_unsafe_raw_sql= is deprecated and will be removed in Rails 7.0")
  end

  self.default_connection_handler = ConnectionAdapters::ConnectionHandler.new
  self.default_role = writing_role
  self.default_shard = :default

  def self.strict_loading_violation!(owner:, reflection:) # :nodoc:
    case action_on_strict_loading_violation
    when :raise
      message = "`#{owner}` is marked for strict_loading. The `#{reflection.klass}` association named `:#{reflection.name}` cannot be lazily loaded."
      raise ActiveRecord::StrictLoadingViolationError.new(message)
    when :log
      name = "strict_loading_violation.active_record"
      ActiveSupport::Notifications.instrument(name, owner: owner, reflection: reflection)
    end
  end
end

# File 'activerecord/lib/active_record/core.rb', line 664

def frozen?
  @attributes.frozen?
end

# File 'activerecord/lib/active_record/core.rb', line 669

def <=>(other_object)
  if other_object.is_a?(self.class)
    to_key <=> other_object.to_key
  else
    super
  end
end