Ruby on Rails 5.2 - ActiveRecord::Core

मॉड्यूल ActiveRecord :: कोर




ruby

मॉड्यूल ActiveRecord :: कोर

पब्लिक क्लास के तरीके

कॉन्फ़िगरेशन () दिखाएँ स्रोत
# File activerecord/lib/active_record/core.rb, line 59
def self.configurations
  @@configurations
end

रिटर्न पूरी तरह से विन्यास हैश हल कर दिया

विन्यास = (विन्यास) स्रोत दिखाएँ
# File activerecord/lib/active_record/core.rb, line 53
def self.configurations=(config)
  @@configurations = ActiveRecord::ConnectionHandling::MergeAndResolveDefaultUrlConfig.new(config).resolve
end

डेटाबेस कॉन्फ़िगरेशन समाहित करता है - जैसा कि आमतौर पर कॉन्फ़िगर / डेटाबेस में संग्रहीत होता है।

उदाहरण के लिए, निम्नलिखित database.yml…

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

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

… परिणाम में ::configurations इस तरह दिखने के लिए ::configurations :

{
   'development' => {
      'adapter'  => 'sqlite3',
      'database' => 'db/development.sqlite3'
   },
   'production' => {
      'adapter'  => 'sqlite3',
      'database' => 'db/production.sqlite3'
   }
}
कनेक्शन_हैंडलर () स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 130
def self.connection_handler
  ActiveRecord::RuntimeRegistry.connection_handler || default_connection_handler
end
connection_handler = (हैंडलर) स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 134
def self.connection_handler=(handler)
  ActiveRecord::RuntimeRegistry.connection_handler = handler
end
new (विशेषताएँ = शून्य) {| स्व | ...} स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 307
def initialize(attributes = nil)
  self.class.define_attribute_methods
  @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')

सार्वजनिक प्रवृत्ति के तरीके

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

वस्तुओं पर छाँटने देता है

सुपरक्लास विधि कहता है
# File activerecord/lib/active_record/core.rb, line 420
def ==(comparison_object)
  super ||
    comparison_object.instance_of?(self.class) &&
    !id.nil? &&
    comparison_object.id == id
end

अगर यह सही है, तो रिटर्न सही है अगर comparison_object एक ही सटीक वस्तु है, या comparison_object एक ही प्रकार की है और self की एक आईडी है और यह तुलना_बॉज के बराबर है।

ध्यान दें कि नए रिकॉर्ड परिभाषा से किसी भी अन्य रिकॉर्ड से अलग हैं, जब तक कि अन्य रिकॉर्ड स्वयं रिसीवर नहीं है। इसके अलावा, यदि आप मौजूदा रिकॉर्ड्स को select और आईडी बाहर छोड़ते हैं, तो आप अपने दम पर हैं, यह विधेय गलत वापस आ जाएगा।

ध्यान दें कि एक रिकॉर्ड को नष्ट करना मॉडल के उदाहरण में अपनी आईडी को संरक्षित करता है, इसलिए हटाए गए मॉडल अभी भी तुलनीय हैं।

सुपरक्लास विधि कहता है
के रूप में भी उपनाम: eql?
# File activerecord/lib/active_record/core.rb, line 369
    

रूबी की क्लोन विधि के लिए पहचान। यह एक "उथली" प्रति है। चेतावनी दें कि आपकी विशेषताओं की प्रतिलिपि नहीं बनाई गई है। इसका मतलब है कि क्लोन की विशेषताओं को संशोधित करने से मूल को संशोधित किया जाएगा, क्योंकि वे दोनों समान विशेषताओं वाले हैश की ओर इशारा करेंगे। यदि आपको अपने विशेषताओं हैश की एक प्रति की आवश्यकता है, तो कृपया विधि का उपयोग करें।

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
कनेक्शन_हैंडलर () स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 471
def connection_handler
  self.class.connection_handler
end
# File activerecord/lib/active_record/core.rb, line 378
    

डुप्लिकेट ऑब्जेक्ट्स को कोई आईडी नहीं दी गई है और उन्हें नए रिकॉर्ड के रूप में माना जाता है। ध्यान दें कि यह एक "उथली" प्रतिलिपि है क्योंकि यह केवल ऑब्जेक्ट की विशेषताओं को कॉपी करता है, न कि इसके संघों को। एक "गहरी" प्रतिलिपि की सीमा आवेदन विशिष्ट है और इसलिए इसे अपनी आवश्यकता के अनुसार लागू करने के लिए आवेदन पर छोड़ दिया गया है। डुबकी विधि टाइमस्टैम्प (निर्मित | अद्यतन) _ (पर | पर) को संरक्षित नहीं करती है।

encode_with (कोडर) दिखाएँ स्रोत
# File activerecord/lib/active_record/core.rb, line 405
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 की संरचना को init_with पद्धति से पारित coder की संरचना से मेल खाने की गारंटी है।

उदाहरण:

class Post < ActiveRecord::Base
end
coder = {}
Post.new.encode_with(coder)
coder # => {"attributes" => {"id" => nil, ... }}
eql? (comparison_object)
इसके लिए उपनाम: ==
# File activerecord/lib/active_record/core.rb, line 441
def freeze
  @attributes = @attributes.clone.freeze
  self
end

क्लोन और विशेषताओं को फ्रीज करें जैसे कि संघ अभी भी नष्ट रिकॉर्ड पर भी सुलभ हैं, लेकिन क्लोन किए गए मॉडल जमे हुए नहीं होंगे।

जमे हुए? () स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 447
def frozen?
  @attributes.frozen?
end

यदि गुण हैश जमे हुए हैं, तो true

# File activerecord/lib/active_record/core.rb, line 430
def hash
  if id
    self.class.hash ^ id.hash
  else
    super
  end
end

एक ही प्रकार के दो रिकॉर्ड और कुछ के साथ काम करने की अनुमति देने के लिए आईडी में प्रतिनिधि:

[ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
सुपरक्लास विधि कहता है
init_with (कोडर) {| स्व | ...} स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 334
def init_with(coder)
  coder = LegacyYamlAdapter.convert(self.class, coder)
  @attributes = self.class.yaml_encoder.decode(coder)

  init_internals

  @new_record = coder["new_record"]

  self.class.define_attribute_methods

  yield self if block_given?

  _run_find_callbacks
  _run_initialize_callbacks

  self
end

coder से खाली मॉडल ऑब्जेक्ट को प्रारंभ करें। coder encode_with होना चाहिए पहले 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'
निरीक्षण () स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 476
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.collect do |name|
      if has_attribute?(name)
        "#{name}: #{attribute_for_inspect(name)}"
      end
    end.compact.join(", ")
  else
    "not initialized"
  end

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

एक अच्छी तरह से स्वरूपित स्ट्रिंग के रूप में रिकॉर्ड की सामग्री लौटाता है।

pretty_print (पीपी) स्रोत दिखाएँ
# File activerecord/lib/active_record/core.rb, line 494
def pretty_print(pp)
  return super if custom_inspect_method_defined?
  pp.object_address_group(self) do
    if defined?(@attributes) && @attributes
      column_names = self.class.column_names.select { |name| has_attribute?(name) || new_record? }
      pp.seplist(column_names, proc { pp.text "," }) do |column_name|
        column_value = read_attribute(column_name)
        pp.breakable " "
        pp.group(1) do
          pp.text column_name
          pp.text ":"
          pp.breakable
          pp.pp column_value
        end
      end
    else
      pp.breakable " "
      pp.text "not initialized"
    end
  end
end

एक पीपी लेता है और इस रिकॉर्ड को पहले से ही प्रिंट कर देता है, जिससे आपको pp record से एक अच्छा परिणाम प्राप्त करने की अनुमति मिलती है जब पीपी की आवश्यकता होती है।

सुपरक्लास विधि कहता है
सिफ़ पढ़िये! () स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 467
def readonly!
  @readonly = true
end

इस रिकॉर्ड को केवल पढ़ने के रूप में चिह्नित करता है।

सिफ़ पढ़िये? () स्रोत दिखाएं
# File activerecord/lib/active_record/core.rb, line 462
def readonly?
  @readonly
end

यदि रिकॉर्ड केवल पढ़ा जाता true तो वापस लौटाता true । गुल्लक-पीठ की विशेषताओं के साथ जुड़ने के माध्यम से लोड किए गए रिकॉर्ड को केवल तभी पढ़ा जाएगा क्योंकि उन्हें बचाया नहीं जा सकता।

टुकड़ा (* विधियाँ) दिखाएँ स्रोत
# File activerecord/lib/active_record/core.rb, line 517
def slice(*methods)
  Hash[methods.flatten.map! { |method| [method, public_send(method)] }].with_indifferent_access
end

दिए गए तरीकों का एक हैश उनके नाम के साथ कुंजी के रूप में देता है और मानों के रूप में लौटाता है।