Module: ActiveRecord::Core

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

included do
  ##
  # :singleton-method:
  #
  # Accepts a logger conforming to the interface of Log4r or the default
  # Ruby Logger class, which is then passed on to any new database
  # connections made. You can retrieve this logger by calling logger on
  # either an Active Record model class or an Active Record model instance.
  class_attribute :logger, instance_writer: false

  class_attribute :_destroy_association_async_job, instance_accessor: false, default: "ActiveRecord::DestroyAssociationAsyncJob"

  # The job class used to destroy associations in the background.
  def self.destroy_association_async_job
    if _destroy_association_async_job.is_a?(String)
      self._destroy_association_async_job = _destroy_association_async_job.constantize
    end
    _destroy_association_async_job
  rescue NameError => error
    raise NameError, "Unable to load destroy_association_async_job: #{error.message}"
  end

  singleton_class.alias_method :destroy_association_async_job=, :_destroy_association_async_job=
  delegate :destroy_association_async_job, to: :class

  ##
  # :singleton-method:
  #
  # Specifies the maximum number of records that will be destroyed in a
  # single background job by the <tt>dependent: :destroy_async</tt>
  # association option. When nil (default), all dependent records will be
  # destroyed in a single background job. If specified, the records to be
  # destroyed will be split into multiple background jobs.
  class_attribute :destroy_association_async_batch_size, instance_writer: false, instance_predicate: false, default: nil

  ##
  # 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: storage/development.sqlite3
  #
  #   production:
  #     adapter: sqlite3
  #     database: storage/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: "storage/development.sqlite3"}>,
  #     #<ActiveRecord::DatabaseConfigurations::HashConfig:0x00007fd1acbdea90 @env_name="production",
  #       @name="primary", @config={adapter: "sqlite3", database: "storage/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:
  # Force enumeration of all columns in SELECT statements.
  # e.g. <tt>SELECT first_name, last_name FROM ...</tt> instead of <tt>SELECT * FROM ...</tt>
  # This avoids PreparedStatementCacheExpired errors when a column is added
  # to the database while the app is running.
  class_attribute :enumerate_columns_in_select_statements, instance_accessor: false, default: false

  class_attribute :belongs_to_required_by_default, instance_accessor: false

  class_attribute :strict_loading_by_default, instance_accessor: false, default: false

  class_attribute :has_many_inversing, instance_accessor: false, default: false

  class_attribute :run_commit_callbacks_on_first_saved_instances_in_transaction, instance_accessor: false, default: true

  class_attribute :default_connection_handler, instance_writer: false

  class_attribute :default_role, instance_writer: false

  class_attribute :default_shard, instance_writer: false

  class_attribute :shard_selector, instance_accessor: false, default: nil

  def self.application_record_class? # :nodoc:
    if ActiveRecord.application_record_class
      self == ActiveRecord.application_record_class
    else
      if defined?(ApplicationRecord) && self == ApplicationRecord
        true
      end
    end
  end

  self.filter_attributes = []

  def self.connection_handler
    ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] || default_connection_handler
  end

  def self.connection_handler=(handler)
    ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] = handler
  end

  def self.asynchronous_queries_session # :nodoc:
    asynchronous_queries_tracker.current_session
  end

  def self.asynchronous_queries_tracker # :nodoc:
    ActiveSupport::IsolatedExecutionState[:active_record_asynchronous_queries_tracker] ||= \
      AsynchronousQueriesTracker.new
  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
    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_class_for_self)
    end

    default_role
  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_class_for_self)
    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
    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_class_for_self)
    end

    false
  end

  def self.connected_to_stack # :nodoc:
    if connected_to_stack = ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack]
      connected_to_stack
    else
      connected_to_stack = Concurrent::Array.new
      ActiveSupport::IsolatedExecutionState[:active_record_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_class_for_self # :nodoc:
    klass = self

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

    klass
  end

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

  def self.strict_loading_violation!(owner:, reflection:) # :nodoc:
    case ActiveRecord.action_on_strict_loading_violation
    when :raise
      message = reflection.strict_loading_violation_message(owner)
      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 645

def blank? # :nodoc:
  false
end

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

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