модуль ActiveRecord::Core

Атрибуты

strict_loading_mode[R]

Публичные методы класса

# File activerecord/lib/active_record/core.rb, line 56
def self.configurations
  @@configurations
end

Возвращает полностью разрешённый объект ActiveRecord::DatabaseConfigurations

configurations=(config) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 50
def self.configurations=(config)
  @@configurations = ActiveRecord::DatabaseConfigurations.new(config)
end

Содержит конфигурацию базы данных — как обычно хранится в файле config/database.yml — в виде объекта ActiveRecord::DatabaseConfigurations.

Например, следующий файл database.yml…

development:
  adapter: sqlite3
  database: db/development.sqlite3

production:
  adapter: sqlite3
  database: db/production.sqlite3

…приведёт к тому, что ActiveRecord::Base.configurations будет выглядеть так:

#<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"}>
]>

connection_handler() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 94
def self.connection_handler
  ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] || default_connection_handler
end

connection_handler=(handler) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 98
def self.connection_handler=(handler)
  ActiveSupport::IsolatedExecutionState[:active_record_connection_handler] = handler
end

connection_handlers() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 102
def self.connection_handlers
  if ActiveRecord.legacy_connection_handling
  else
    raise NotImplementedError, "The new connection handling does not support accessing multiple connection handlers."
  end

  @@connection_handlers ||= {}
end

connection_handlers=(handlers) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 111
      def self.connection_handlers=(handlers)
        if ActiveRecord.legacy_connection_handling
          ActiveSupport::Deprecation.warn(<<~MSG)
            Using legacy connection handling is deprecated. Please set
            `legacy_connection_handling` to `false` in your application.

            The new connection handling does not support `connection_handlers`
            getter and setter.

            Read more about how to migrate at: https://guides.rubyonrails.org/active_record_multiple_databases.html#migrate-to-the-new-connection-handling
          MSG
        else
          raise NotImplementedError, "The new connection handling does not support multiple connection handlers."
        end

        @@connection_handlers = handlers
      end

current_preventing_writes() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 188
def self.current_preventing_writes
  if ActiveRecord.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_class_for_self)
    end

    false
  end
end

Возвращает символ, представляющий текущее значение для предотвращения записи.

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

current_role() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 147
def self.current_role
  if ActiveRecord.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_class_for_self)
    end

    default_role
  end
end

Возвращает символ, представляющий текущую подключённую роль.

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

current_shard() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 169
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

Возвращает символ, представляющий текущий подключённый фрагмент.

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

new(attributes = nil) { |self| ... } Показать исходный код

# File activerecord/lib/active_record/core.rb, line 461
def initialize(attributes = nil)
  @new_record = true
  @attributes = self.class._default_attributes.deep_dup

  init_internals
  initialize_internals_callback

  assign_attributes(attributes) if attributes

  yield self if block_given?
  _run_initialize_callbacks
end

Новые объекты могут быть созданы как пустые (не передавая параметров) или предварительно заполненные атрибутами, но ещё не сохранённые (передавая хэш с именами ключей, соответствующими именам столбцов таблицы). В обоих случаях, допустимые ключи атрибутов определяются именами столбцов связанной таблицы — поэтому у вас не может быть атрибутов, которые не являются частью столбцов таблицы.

Пример:

# Instantiates a single new object
User.new(first_name: 'Jamie')

Публичные методы экземпляров

<=>(other_object) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 614
def <=>(other_object)
  if other_object.is_a?(self.class)
    to_key <=> other_object.to_key
  else
    super
  end
end

Разрешает сортировку объектов

Вызывается метод суперкласса

==(comparison_object) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 580
def ==(comparison_object)
  super ||
    comparison_object.instance_of?(self.class) &&
    !id.nil? &&
    comparison_object.id == id
end

Возвращает true, если comparison_object — это тот же самый объект, или comparison_object имеет тот же тип и self имеет идентификатор, равный comparison_object.id.

Обратите внимание, что новые записи по определению отличаются от любых других записей, если только другая запись не является самим получателем. Кроме того, если вы извлекаете существующие записи с помощью select и опускаете идентификатор, вы на свой страх и риск; в этом случае предикат вернёт false.

Обратите также внимание, что удаление записи сохраняет её идентификатор в экземпляре модели, поэтому удалённые модели по-прежнему сравнимы.

Вызывается метод суперкласса

Также алиас для: eql?

clone() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 513

Идентично методу clone в Ruby. Это «поверхностная» копия. Будьте осторожны, ваши атрибуты не копируются. Это означает, что изменение атрибутов копии изменит оригинал, поскольку они оба будут указывать на один и тот же хеш атрибутов. Если вам нужна копия хеша ваших атрибутов, используйте метод dup.

user = User.first
new_user = user.clone
user.name               # => "Bob"
new_user.name = "Joe"
user.name               # => "Joe"

user.object_id == new_user.object_id            # => false
user.name.object_id == new_user.name.object_id  # => true

user.name.object_id == user.dup.name.object_id  # => false

connection_handler() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 682
def connection_handler
  self.class.connection_handler
end

dup() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 530

Дублированные объекты не имеют назначенного идентификатора и обрабатываются как новые записи. Обратите внимание, что это «поверхностная» копия, так как она копирует только атрибуты объекта, а не его ассоциации. Степень «глубокой» копии зависит от приложения, поэтому её реализация возлагается на приложение в соответствии с его потребностями. Метод dup не сохраняет временные метки (created|updated)_(at|on).

encode_with(coder) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 565
def encode_with(coder)
  self.class.yaml_encoder.encode(@attributes, coder)
  coder["new_record"] = new_record?
  coder["active_record_yaml_version"] = 2
end

Заполните coder атрибутами этой записи, которые должны быть сериализованы. Структура coder , определённая в этом методе, гарантированно соответствует структуре coder , переданной методу init_with.

Пример:

class Post < ActiveRecord::Base
end
coder = {}
Post.new.encode_with(coder)
coder # => {"attributes" => {"id" => nil, ... }}

eql?(comparison_object)

Алиас для: ==

freeze() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 603
def freeze
  @attributes = @attributes.clone.freeze
  self
end

Клонирует и замораживает хеш атрибутов таким образом, что ассоциации по-прежнему доступны, даже для удалённых записей, но клонированные модели не будут заморожены.

frozen?() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 609
def frozen?
  @attributes.frozen?
end

Возвращает true, если хеш атрибутов заморожен.

hash() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 590
def hash
  id = self.id

  if id
    self.class.hash ^ id.hash
  else
    super
  end
end

Делегирует вызов к id, чтобы две записи одного типа и идентификатора работали с чем-то вроде:

[ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]

Вызывается метод суперкласса

init_with(coder, &block) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 488
def init_with(coder, &block)
  coder = LegacyYamlAdapter.convert(coder)
  attributes = self.class.yaml_encoder.decode(coder)
  init_with_attributes(attributes, coder["new_record"], &block)
end

Инициализирует пустой объект модели из coder. coder должен быть результатом предыдущего кодирования модели Active Record с использованием encode_with.

class Post < ActiveRecord::Base
end

old_post = Post.new(title: "hello world")
coder = {}
old_post.encode_with(coder)

post = Post.allocate
post.init_with(coder)
post.title # => 'hello world'

inspect() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 687
def inspect
  # We check defined?(@attributes) not to issue warnings if the object is
  # allocated but not initialized.
  inspection = if defined?(@attributes) && @attributes
    self.class.attribute_names.filter_map do |name|
      if _has_attribute?(name)
        "#{name}: #{attribute_for_inspect(name)}"
      end
    end.join(", ")
  else
    "not initialized"
  end

  "#<#{self.class} #{inspection}>"
end

Возвращает содержимое записи в виде отформатированной строки.

pretty_print(pp) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 705
def pretty_print(pp)
  return super if custom_inspect_method_defined?
  pp.object_address_group(self) do
    if defined?(@attributes) && @attributes
      attr_names = self.class.attribute_names.select { |name| _has_attribute?(name) }
      pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
        pp.breakable " "
        pp.group(1) do
          pp.text attr_name
          pp.text ":"
          pp.breakable
          value = _read_attribute(attr_name)
          value = inspection_filter.filter_param(attr_name, value) unless value.nil?
          pp.pp value
        end
      end
    else
      pp.breakable " "
      pp.text "not initialized"
    end
  end
end

Принимает PP и красиво выводит эту запись в него, что позволяет получить хороший результат от pp record при необходимости pp.

Вызывается метод суперкласса

readonly!() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 678
def readonly!
  @readonly = true
end

Помечает эту запись как только для чтения.

readonly?() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 631
def readonly?
  @readonly
end

Возвращает true, если запись является только для чтения.

slice(*methods) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 729
def slice(*methods)
  methods.flatten.index_with { |method| public_send(method) }.with_indifferent_access
end

Возвращает хеш заданных методов с их именами в качестве ключей и возвращаемыми значениями в качестве значений.

strict_loading!(value = true, mode: :all) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 661
def strict_loading!(value = true, mode: :all)
  unless [:all, :n_plus_one_only].include?(mode)
    raise ArgumentError, "The :mode option must be one of [:all, :n_plus_one_only]."
  end

  @strict_loading_mode = mode
  @strict_loading = value
end

Устанавливает режим strict_loading для записи. Это вызовет ошибку, если запись попытается загрузить ассоциацию ленивым способом.

user = User.first
user.strict_loading! # => true
user.comments
=> ActiveRecord::StrictLoadingViolationError

Параметры:

value - Булевое значение, указывающее, включить или отключить strict loading.

mode - Symbol, указывающий режим strict loading. По умолчанию :all. Используя

:n_plus_one_only mode will only raise an error if an association
that will lead to an n plus one query is lazily loaded.

Пример:

user = User.first
user.strict_loading!(false) # => false
user.comments
=> #<ActiveRecord::Associations::CollectionProxy>

strict_loading?() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 636
def strict_loading?
  @strict_loading
end

Возвращает true, если запись находится в режиме strict_loading.

strict_loading_n_plus_one_only?() Показать исходный код

# File activerecord/lib/active_record/core.rb, line 673
def strict_loading_n_plus_one_only?
  @strict_loading_mode == :n_plus_one_only
end

Возвращает true, если запись использует strict_loading с включённым режимом :n_plus_one_only.

values_at(*methods) Показать исходный код

# File activerecord/lib/active_record/core.rb, line 734
def values_at(*methods)
  methods.flatten.map! { |method| public_send(method) }
end

Возвращает массив значений, возвращаемых заданными методами.