Ruby on Rails
ActiveRecord संघों

का है

एक belongs_to एक और मॉडल के साथ एक-से-एक कनेक्शन है, की घोषणा मॉडल के प्रत्येक उदाहरण इतनी संघ सेट अन्य मॉडल का एक उदाहरण "के अंतर्गत आता है"।

उदाहरण के लिए, यदि आपके एप्लिकेशन में उपयोगकर्ता और पोस्ट शामिल हैं, और प्रत्येक पोस्ट को ठीक एक उपयोगकर्ता को सौंपा जा सकता है, तो आप पोस्ट मॉडल को इस तरह से घोषित करेंगे:

class Post < ApplicationRecord
  belongs_to :user
end

आपकी तालिका संरचना में आप तब हो सकते हैं

create_table "posts", force: :cascade do |t|
  t.integer  "user_id",  limit: 4
end

एक है

एक has_one एसोसिएशन दूसरे मॉडल के साथ एक-से-एक कनेक्शन सेट करता है, लेकिन विभिन्न शब्दार्थों के साथ। यह एसोसिएशन इंगित करता है कि एक मॉडल के प्रत्येक उदाहरण में किसी अन्य मॉडल का एक उदाहरण होता है या होता है।

उदाहरण के लिए, यदि आपके आवेदन में प्रत्येक उपयोगकर्ता का केवल एक ही खाता है, तो आप उपयोगकर्ता मॉडल को इस तरह घोषित करेंगे:

class User < ApplicationRecord
  has_one :account
end

सक्रिय रिकॉर्ड में, जब आपके पास एक has_one संबंध है, तो सक्रिय रिकॉर्ड यह सुनिश्चित करता है कि केवल एक रिकॉर्ड विदेशी कुंजी के साथ मौजूद है।

यहां हमारे उदाहरण में: लेखा तालिका में, किसी विशेष उपयोगकर्ता_ के साथ केवल एक रिकॉर्ड हो सकता है। यदि आप एक ही उपयोगकर्ता के लिए एक और खाते को जोड़ने की कोशिश करते हैं, तो यह पिछली प्रविष्टि की विदेशी कुंजी को अशक्त (अनाथ बनाकर) बनाता है और स्वचालित रूप से एक नया बनाता है। यह नई प्रविष्टि के लिए स्थिरता बनाए रखने में विफल होने पर भी पिछली प्रविष्टि को अशक्त बनाता है।

user = User.first
user.build_account(name: "sample")
user.save   [Saves it successfully, and creates an entry in accounts table with user_id 1]
user.build_account(name: "sample1")  [automatically makes the previous entry's foreign key null]
user.save  [creates the new account with name sample 1 and user_id 1]

बहुत सारे

एक has_many एसोसिएशन किसी अन्य मॉडल के साथ एक-से-कई कनेक्शन को इंगित करता है। यह एसोसिएशन आम तौर पर एक rel_to एसोसिएशन के दूसरी तरफ स्थित है।

यह एसोसिएशन इंगित करता है कि मॉडल के प्रत्येक उदाहरण में किसी अन्य मॉडल के शून्य या अधिक उदाहरण हैं।

उदाहरण के लिए, उपयोगकर्ताओं और पदों वाले एप्लिकेशन में, उपयोगकर्ता मॉडल को इस तरह घोषित किया जा सकता है:

class User < ApplicationRecord
  has_many :posts
end

Post की तालिका संरचना उसी प्रकार बनी रहेगी जैसे कि belongs_to ; इसके विपरीत, User को किसी भी स्कीमा परिवर्तन की आवश्यकता नहीं होगी।

यदि आप User लिए सभी प्रकाशित पदों की सूची प्राप्त करना चाहते हैं, तो आप निम्नलिखित जोड़ सकते हैं (यानी आप अपने एसोसिएशन ऑब्जेक्ट्स में स्कोप जोड़ सकते हैं):

class User < ApplicationRecord
  has_many :published_posts, -> { where("posts.published IS TRUE") }, class_name: "Post"
end

बहुरूपी संघ

इस प्रकार के संघ एक ActiveRecord मॉडल को एक से अधिक प्रकार के मॉडल रिकॉर्ड से संबंधित होने की अनुमति देता है। आम उदाहरण:

class Human < ActiveRecord::Base
  has_one :address, :as => :addressable
end

class Company < ActiveRecord::Base
  has_one :address, :as => :addressable
end

class Address < ActiveRecord::Base
  belongs_to :addressable, :polymorphic => true
end

इस संगति के बिना, आपके पते की तालिका में ये सभी विदेशी कुंजियाँ होंगी, लेकिन आपके पास कभी भी उनमें से किसी एक के लिए एक मान होगा क्योंकि इस परिदृश्य में, एक पता केवल एक इकाई (मानव या कंपनी) का हो सकता है। यहाँ है कि यह कैसा दिखेगा:

class Address < ActiveRecord::Base
  belongs_to :human
  belongs_to :company
end

Has_many: एसोसिएशन के माध्यम से

A has_many :through एसोसिएशन के has_many :through से अक्सर दूसरे मॉडल के साथ many-to-many कनेक्शन सेट करने के लिए उपयोग किया जाता है। यह एसोसिएशन इंगित करता है कि घोषित मॉडल को तीसरे मॉडल के माध्यम से आगे बढ़ते हुए किसी अन्य मॉडल के शून्य या अधिक उदाहरणों के साथ मिलान किया जा सकता है।

उदाहरण के लिए, एक चिकित्सा पद्धति पर विचार करें जहां चिकित्सक चिकित्सकों को देखने के लिए नियुक्तियां करते हैं। संबंधित एसोसिएशन की घोषणाएं इस तरह दिख सकती हैं:

class Physician < ApplicationRecord
  has_many :appointments
  has_many :patients, through: :appointments
end

class Appointment < ApplicationRecord
  belongs_to :physician
  belongs_to :patient
end

class Patient < ApplicationRecord
  has_many :appointments
  has_many :physicians, through: :appointments
end

Has_one: एसोसिएशन के माध्यम से

A has_one :through एसोसिएशन के has_one :through से दूसरे मॉडल के साथ one-to-one कनेक्शन सेट करता है। यह एसोसिएशन इंगित करता है कि घोषित मॉडल को तीसरे मॉडल के माध्यम से आगे बढ़ते हुए दूसरे मॉडल के एक उदाहरण के साथ मिलान किया जा सकता है।

उदाहरण के लिए, यदि प्रत्येक supplier का एक account , और प्रत्येक खाता एक खाता इतिहास से जुड़ा है, तो आपूर्तिकर्ता मॉडल इस तरह दिख सकता है:

class Supplier < ApplicationRecord
  has_one :account
  has_one :account_history, through: :account
end

class Account < ApplicationRecord
  belongs_to :supplier
  has_one :account_history
end

class AccountHistory < ApplicationRecord
  belongs_to :account
end

Has_and_belongs_to_many एसोसिएशन

एक has_and_belongs_to_many एसोसिएशन किसी अन्य मॉडल के साथ कोई हस्तक्षेप नहीं करने वाले मॉडल के साथ many-to-many प्रत्यक्ष many-to-many संबंध बनाता है।

उदाहरण के लिए, यदि आपके एप्लिकेशन में assemblies और parts , प्रत्येक असेंबली में कई भागों और प्रत्येक भाग में कई असेंबली दिखाई देती हैं, तो आप इस तरह से मॉडल घोषित कर सकते हैं:

class Assembly < ApplicationRecord
  has_and_belongs_to_many :parts
end

class Part < ApplicationRecord
  has_and_belongs_to_many :assemblies
end

सेल्फ रेफरेंशियल एसोसिएशन

सेल्फ-रेफरेंशियल एसोसिएशन का उपयोग किसी मॉडल को खुद से जोड़ने के लिए किया जाता है। सबसे लगातार उदाहरण एक दोस्त और उसके अनुयायी के बीच सहयोग का प्रबंधन करना होगा।

पूर्व।

rails g model friendship user_id:references friend_id:integer

अब आप जैसे मॉडल को जोड़ सकते हैं;

class User < ActiveRecord::Base
  has_many :friendships
  has_many :friends, :through => :friendships
  has_many :inverse_friendships, :class_name => "Friendship", :foreign_key => "friend_id"
  has_many :inverse_friends, :through => :inverse_friendships, :source => :user
end

और दूसरा मॉडल जैसा दिखेगा;

class Friendship < ActiveRecord::Base
  belongs_to :user
  belongs_to :friend, :class_name => "User"
end